cslib.shar

书名:C语言科学与艺术,以前交钱下载的

X/*
X * Function: SetEraseMode
X * Usage: SetEraseMode(TRUE);
X *        SetEraseMode(FALSE);
X * ---------------------------
X * The SetEraseMode function sets the value of the internal
X * erasing flag.  Setting this flag is similar to setting the
X * color to "White" in its effect but does not affect the
X * current color setting.  When erase mode is set to FALSE,
X * normal drawing is restored, using the current color.
X */
X
Xvoid SetEraseMode(bool mode);
X
X/*
X * Function: GetEraseMode
X * Usage: mode = GetEraseMode();
X * -----------------------------
X * This function returns the current state of the erase mode flag.
X */
X
Xbool GetEraseMode(void);
X
X/*
X * Function: SetWindowTitle
X * Usage: SetWindowTitle(title);
X * -----------------------------
X * This function sets the title of the graphics window, if such
X * an operation is possible on the display.  If it is not possible
X * for a particular implementation, the call is simply ignored.
X * This function may be called prior to the InitGraphics call to
X * set the initial name of the window.
X */
X
Xvoid SetWindowTitle(string title);
X
X/*
X * Function: GetWindowTitle
X * Usage: title = GetWindowTitle();
X * --------------------------------
X * This function returns the title of the graphics window.  If the
X * implementation does not support titles, this call returns the
X * empty string.
X */
X
Xstring GetWindowTitle(void);
X
X/*
X * Function: UpdateDisplay
X * Usage: UpdateDisplay();
X * -----------------------
X * This function initiates an immediate update of the graphics
X * window and is necessary for animation.  Ordinarily, the
X * graphics window is updated only when the program waits for
X * user input.
X */
X
Xvoid UpdateDisplay(void);
X
X/*
X * Function: Pause
X * Usage: Pause(seconds);
X * ----------------------
X * The Pause function updates the graphics window and then
X * pauses for the indicated number of seconds.  This function
X * is useful for animation where the motion would otherwise
X * be too fast.
X */
X
Xvoid Pause(double seconds);
X
X/*
X * Function: ExitGraphics
X * Usage: ExitGraphics();
X * ----------------------
X * The ExitGraphics function closes the graphics window and
X * exits from the application without waiting for any additional
X * user interaction.
X */
X
Xvoid ExitGraphics(void);
X
X/*
X * Functions: SaveGraphicsState, RestoreGraphicsState
X * Usage: SaveGraphicsState();
X *        . . . graphical operations . . .
X *        RestoreGraphicsState();
X * ---------------------------------------------------
X * The SaveGraphicsState function saves the current graphics
X * state (the current pen position, the font, the point size,
X * and the erase mode flag) internally, so that they can be
X * restored by the next RestoreGraphicsState call.  These two
X * functions must be used in pairs but may be nested to any depth.
X */
X
Xvoid SaveGraphicsState(void);
Xvoid RestoreGraphicsState(void);
X
X/*
X * Functions: GetFullScreenWidth, GetFullScreenHeight
X * Usage: width = GetFullScreenWidth();
X *        height = GetFullScreenHeight();
X * --------------------------------------
X * These functions return the height and width of the entire
X * display screen, not the graphics window.  Their only
X * significant use is for applications that need to adjust
X * the size of the graphics window based on available screen
X * space.  These functions may be called before InitGraphics
X * has been called.
X */
X
Xdouble GetFullScreenWidth(void);
Xdouble GetFullScreenHeight(void);
X
X/*
X * Functions: SetWindowSize
X * Usage: SetWindowSize(width, height);
X * ------------------------------------
X * This function sets the window size to the indicated dimensions,
X * if possible.  This function should be called before the graphics
X * window is created by InitGraphics.  Attempts to change the size
X * of an existing window are ignored by most implementations.  This
X * function should be used sparingly because it reduces the
X * portability of applications, particularly if the client
X * requests more space than is available on the screen.
X */
X
Xvoid SetWindowSize(double width, double height);
X
X/*
X * Functions: GetXResolution, GetYResolution
X * Usage: xres = GetXResolution();
X *        yres = GetYResolution();
X * -----------------------------------------
X * These functions return the number of pixels per inch along
X * each of the coordinate directions and are useful for applications
X * in which it is important for short distances to be represented
X * uniformly in terms of dot spacing.  Even though the x and y
X * resolutions are the same for most displays, clients should
X * not rely on this property.
X *
X * Note: Lines in the graphics library are one pixel unit wide and
X * have a length that is always one pixel longer than you might
X * expect.  For example, the function call
X *
X *     DrawLine(2 / GetXResolution(), 0);
X *
X * draws a line from the current point to the point two pixels
X * further right, which results in a line of three pixels.
X */
X
Xdouble GetXResolution(void);
Xdouble GetYResolution(void);
X
X#endif
END_OF_FILE
if test 14869 -ne `wc -c <'cslib/extgraph.h'`; then
    echo shar: \"'cslib/extgraph.h'\" unpacked with wrong size!
fi
# end of 'cslib/extgraph.h'
fi
if test -f 'cslib/gcalloc.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/gcalloc.h'\"
else
echo shar: Extracting \"'cslib/gcalloc.h'\" \(2269 characters\)
sed "s/^X//" >'cslib/gcalloc.h' <<'END_OF_FILE'
X/*
X * File: gcalloc.h
X * Version: 1.0
X * Last modified on Wed Sep 21 16:21:37 1994 by eroberts
X * -----------------------------------------------------
X * This file is a stub version of the interface for a
X * garbage-collecting allocator that will be part of
X * a future library release.  When the garbage-collecting
X * allocator is in use, the memory returned by the GetBlock
X * and FreeBlock functions in genlib.h can be traced and
X * collected automatically when it is no longer accessible.
X *
X * The garbage-collecting allocator is not part of the
X * current cslib distribution.  Even so, functions in the
X * other libraries call the ProtectVariable and ProtectBlock
X * functions, so that they will continue to work when the
X * full library is released.  Those functions are implemented
X * in genlib.c.
X */
X
X#ifndef _gcalloc_h
X#define _gcalloc_h
X
X/*
X * Macro: ProtectVariable
X * Usage: ProtectVariable(v);
X * --------------------------
X * This macro registers a global variable with the allocation
X * system, so that the variable is traced when the garbage
X * collector is used.  This operation needs is implemented
X * in genlib.c so that code can be written to function correctly
X * whether or not the garbage-collecting allocator is loaded.
X */
X
X#define ProtectVariable(v) ProtectBlock(&v, sizeof v)
X
X/*
X * Function: ProtectBlock
X * Usage: ProtectBlock(ptr, nbytes);
X * ---------------------------------
X * This function is not usually called by clients (who will
X * ordinarily use ProtectVariable instead), but has the
X * effect of protecting the block of memory beginning at
X * ptr and extending for nbytes from the garbage collector.
X */
X
Xvoid ProtectBlock(void *ptr, size_t nbytes);
X
X/*
X * Global linkage variable: _acb
X * -----------------------------
X * This variable is used to hold the allocation control block
X * that provides the linkage between this package and the
X * dynamic allocator.  The reason for using the structure
X * as a linkage is so that the garbage-collecting allocator
X * need not even be loaded if it is not explicitly called.
X */
X
Xtypedef struct {
X    void *(*allocMethod)(size_t nbytes);
X    void (*freeMethod)(void *ptr);
X    void (*protectMethod)(void *ptr, size_t nbytes);
X} *_GCControlBlock;
X
Xextern _GCControlBlock _acb;
X
X#endif
END_OF_FILE
if test 2269 -ne `wc -c <'cslib/gcalloc.h'`; then
    echo shar: \"'cslib/gcalloc.h'\" unpacked with wrong size!
fi
# end of 'cslib/gcalloc.h'
fi
if test -f 'cslib/genlib.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/genlib.c'\"
else
echo shar: Extracting \"'cslib/genlib.c'\" \(3748 characters\)
sed "s/^X//" >'cslib/genlib.c' <<'END_OF_FILE'
X/*
X * File: genlib.c
X * Version: 1.0
X * Last modified on Sun Jul 24 10:29:46 1994 by eroberts
X * -----------------------------------------------------
X * This file implements the general C library package.  See the
X * interface description in genlib.h for details.
X */
X
X#include <stdio.h>
X#include <stddef.h>
X#include <string.h>
X#include <stdarg.h>
X
X#include "genlib.h"
X#include "gcalloc.h"
X#include "exception.h"
X
X/*
X * Constants:
X * ----------
X * ErrorExitStatus -- Status value used in exit call
X * MaxErrorMessage -- Longest error message allowed
X */
X
X#define ErrorExitStatus 1
X#define MaxErrorMessage 500
X
X/* Section 1 -- Define new "primitive" types */
X
X/*
X * Constant: UNDEFINED
X * -------------------
X * This entry defines the target of the UNDEFINED constant.
X */
X
Xchar undefined_object[] = "UNDEFINED";
X
X/* Section 2 -- Memory allocation */
X
X/*
X * Implementation notes:
X * ---------------------
X * The code for the memory allocator is divided between
X * genlib.c and gcalloc.c, and the division strategy may at
X * first seem unnatural, since the function ProtectBlock is
X * declared in gcalloc.h but defined here in genlib.c.  The
X * intention is to minimize the size of object files
X * produced by linkers that search a library for modules
X * that are actually referenced.  The libraries themselves
X * need to call ProtectBlock (usually through the macro
X * ProtectVariable), but will not require the actual code
X * for the allocator unless InitGCAllocator is explicitly
X * called.
X */
X
X/*
X * Global variable: _acb
X * ---------------------
X * This variable is used to hold a method suite that makes it
X * easy to substitute a garbage-collecting allocator for the
X * ANSI allocator.
X */
X
X_GCControlBlock _acb = NULL;
X
X/* Memory allocation implementation */
X
Xvoid *GetBlock(size_t nbytes)
X{
X    void *result;
X
X    if (_acb == NULL) {
X        result = malloc(nbytes);
X    } else {
X        result = _acb->allocMethod(nbytes);
X    }
X    if (result == NULL) Error("No memory available");
X    return (result);
X}
X
Xvoid FreeBlock(void *ptr)
X{
X    if (_acb == NULL) {
X        free(ptr);
X    } else {
X        _acb->freeMethod(ptr);
X    }
X}
X
Xvoid ProtectBlock(void *ptr, size_t nbytes)
X{
X    if (_acb != NULL) _acb->protectMethod(ptr, nbytes);
X}
X
X/* Section 3 -- Basic error handling */
X
X/*
X * Implementation notes: Error
X * ---------------------------
X * Writing the Error function requires some care, since it is
X * called in circumstances in which parts of the system may be
X * broken.  In particular, it is not acceptable for Error to
X * call GetBlock, since the error condition may be that the
X * system is out of memory, in which case calling GetBlock would
X * fail.  The error string should be allocated dynamically,
X * so that this function can be used in reentrant code.
X * Note that it is critical to exit if the length bound for
X * an error message is exceeded, since this error almost
X * certainly corrupts the stack.
X */
X
Xvoid Error(string msg, ...)
X{
X    va_list args;
X    char errbuf[MaxErrorMessage + 1];
X    string errmsg;
X    int errlen;
X
X    va_start(args, msg);
X    vsprintf(errbuf, msg, args);
X    va_end(args);
X    errlen = strlen(errbuf);
X    if (errlen > MaxErrorMessage) {
X        fprintf(stderr, "Error: Error Message too long\n");
X        exit(ErrorExitStatus);
X    }
X    if (_acb == NULL) {
X        errmsg = malloc(errlen + 1);
X    } else {
X        errmsg = _acb->allocMethod(errlen + 1);
X    }
X    if (errmsg == NULL) {
X        errmsg = "No memory available";
X    } else {
X        strcpy(errmsg, errbuf);
X    }
X    if (HandlerExists(&ErrorException)) {
X        RaiseException(&ErrorException, "ErrorException", errmsg);
X    } else {
X        fprintf(stderr, "Error: %s\n", errmsg);
X        exit(ErrorExitStatus);
X    }
X}
END_OF_FILE
if test 3748 -ne `wc -c <'cslib/genlib.c'`; then
    echo shar: \"'cslib/genlib.c'\" unpacked with wrong size!
fi
# end of 'cslib/genlib.c'
fi
if test -f 'cslib/genlib.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/genlib.h'\"
else
echo shar: Extracting \"'cslib/genlib.h'\" \(6232 characters\)
sed "s/^X//" >'cslib/genlib.h' <<'END_OF_FILE'
X/*
X * File: genlib.h
X * Version: 1.0
X * Last modified on Sun Jul 24 10:32:49 1994 by eroberts
X * -----------------------------------------------------
X * This file contains several definitions that form the
X * core of a general-purpose ANSI C library developed by Eric
X * Roberts.  The goal of this library is to provide a basic
X * set of tools and conventions that increase the readability
X * of C programs, particularly as they are used in a teaching
X * environment.
X *
X * The basic definitions provided by genlib.h are:
X *
X *    1.  Declarations for several new "primitive" types
X *        (most importantly bool and string) that are
X *        used throughout the other libraries and
X *        applications as fundamental types.
X *
X *    2.  A new set of functions for memory allocation.
X *
X *    3.  A function for error handling.
X *
X *    4.  A repeat statement for loops with interior exits.
X */
X
X#ifndef _genlib_h
X#define _genlib_h
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <stddef.h>
X
X/* Section 1 -- Define new "primitive" types */
X
X/*
X * Type: bool
X * ----------
X * This type has two values, FALSE and TRUE, which are equal to 0
X * and 1, respectively.  Most of the advantage of defining this type
X * comes from readability because it allows the programmer to
X * provide documentation that a variable will take on only one of
X * these two values.  Designing a portable representation, however,
X * is surprisingly hard, because many libraries and some compilers
X * define these names.  The definitions are usually compatible but
X * may still be flagged as errors.
X */
X
X#ifdef THINK_C
X   typedef int bool;
X#else
X#  ifdef TRUE