cslib.shar

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

X#    ifndef bool
X#      define bool int
X#    endif
X#  else
X#    ifdef bool
X#      define FALSE 0
X#      define TRUE 1
X#    else
X       typedef enum {FALSE, TRUE} bool;
X#    endif
X#  endif
X#endif
X
X/*
X * Type: string
X * ------------
X * The type string is identical to the type char *, which is
X * traditionally used in C programs.  The main point of defining a
X * new type is to improve program readability.   At the abstraction
X * levels at which the type string is used, it is usually not
X * important to take the string apart into its component characters.
X * Declaring it as a string emphasizes this atomicity.
X */
X
Xtypedef char *string;
X
X/*
X * Type: stream
X * ------------
X * Like string, the stream type is used to provide additional
X * readability and is defined to be equivalent to FILE *
X * (which is particularly confusing because it violates
X * standard case conventions).  This type is not used in
X * the text but is preserved in genlib.h, so it is possible
X * to teach all of CS1 without exposing any pointers.
X */
X
Xtypedef FILE *stream;
X
X/*
X * Constant: UNDEFINED
X * -------------------
X * Besides NULL, the only other constant of pointer type is
X * UNDEFINED, which is used in certain packages as a special
X * sentinel to indicate an undefined pointer value.  In many
X * such contexts, NULL is a legitimate data value and is
X * therefore inappropriate as a sentinel.
X */
X
X#define UNDEFINED ((void *) undefined_object)
X
Xextern char undefined_object[];
X
X/* Section 2 -- Memory allocation */
X
X/*
X * General notes:
X * --------------
X * These functions provide a common interface for memory
X * allocation.  All functions in the library that allocate
X * memory do so using GetBlock and FreeBlock.  Even though
X * the ANSI standard defines malloc and free for the same
X * purpose, using GetBlock and FreeBlock provides greater
X * compatibility with non-ANSI implementations, automatic
X * out-of-memory error detection, and the possibility of
X * substituting a garbage-collecting allocator.
X */
X
X/*
X * Function: GetBlock
X * Usage: ptr = (type) GetBlock(nbytes);
X * -------------------------------------
X * GetBlock allocates a block of memory of the given size.  If
X * no memory is available, GetBlock generates an error.
X */
X
Xvoid *GetBlock(size_t nbytes);
X
X/*
X * Function: FreeBlock
X * Usage: FreeBlock(ptr);
X * ----------------------
X * FreeBlock frees the memory associated with ptr, which must
X * have been allocated using GetBlock, New, or NewArray.
X */
X
Xvoid FreeBlock(void *ptr);
X
X/*
X * Macro: New
X * Usage: p = New(pointer-type);
X * -----------------------------
X * The New pseudofunction allocates enough space to hold an
X * object of the type to which pointer-type points and returns
X * a pointer to the newly allocated pointer.  Note that
X * "New" is different from the "new" operator used in C++;
X * the former takes a pointer type and the latter takes the
X * target type.
X */
X
X#define New(type) ((type) GetBlock(sizeof *((type) NULL)))
X
X/*
X * Macro: NewArray
X * Usage: p = NewArray(n, element-type);
X * -------------------------------------
X * NewArray allocates enough space to hold an array of n
X * values of the specified element type.
X */
X
X#define NewArray(n, type) ((type *) GetBlock((n) * sizeof (type)))
X
X/* Section 3 -- Basic error handling */
X
X/*
X * Function: Error
X * Usage: Error(msg, ...)
X * ----------------------
X * Error generates an error string, expanding % constructions
X * appearing in the error message string just as printf does.
X * If an error handler exception has been introduced (see the
X * "exception.h" facility), the ErrorException exception is
X * raised with the expanded error string as argument.  If
X * there is no ErrorException defined, the program exits
X * with a status code indicating failure (as given by the
X * constant ErrorExitStatus).  The length of the error
X * message string following expansion must not exceed
X * MaxErrorMessage, and it is the client's responsibility
X * to ensure this.
X */
X
Xvoid Error(string msg, ...);
X
X/* Section 4 -- The repeat pseudo-statement */
X
X/*
X * Statement form: repeat { ... }
X * ------------------------------
X * Some instructors who have taught CS1 using this library
X * have found that using
X *
X *     while (TRUE)
X *
X * to initiate a loop with an interior exit is confusing to
X * students, particularly when it comes at the beginning of
X * the course.  This macro defines "repeat" as an infinite
X * loop construct for instructors who find it easier to
X * explain, although it is not used in the text.   Similar
X * macro definitions are common in industry.
X */
X
X#define repeat for (;;)
X
X#endif
END_OF_FILE
if test 6232 -ne `wc -c <'cslib/genlib.h'`; then
    echo shar: \"'cslib/genlib.h'\" unpacked with wrong size!
fi
# end of 'cslib/genlib.h'
fi
if test -f 'cslib/glibrary.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/glibrary.c'\"
else
echo shar: Extracting \"'cslib/glibrary.c'\" \(818 characters\)
sed "s/^X//" >'cslib/glibrary.c' <<'END_OF_FILE'
X/*
X * File: glibrary.c
X * Version: 3.0
X * Last modified on Sat Oct  1 12:28:01 1994 by eroberts
X * -----------------------------------------------------
X * This file implements the simple functions in the glibrary.h
X * interface.
X */
X
X#include <stdio.h>
X#include <math.h>
X#include "genlib.h"
X
X/* Constants */
X
X#define Pi 3.1415926535
X
X/* Exported entries */
X
Xdouble GLRadians(double degrees)
X{
X    return (degrees * Pi / 180);
X}
X
Xdouble GLDegrees(double radians)
X{
X    return (radians * 180 / Pi);
X}
X
Xint GLRound(double x)
X{
X    return ((int) floor(x + 0.5));
X}
X
Xint GLMin(int x, int y)
X{
X    return ((x < y) ? x : y);
X}
X
Xint GLMax(int x, int y)
X{
X    return ((x > y) ? x : y);
X}
X
Xdouble GLMinF(double x, double y)
X{
X    return ((x < y) ? x : y);
X}
X
Xdouble GLMaxF(double x, double y)
X{
X    return ((x > y) ? x : y);
X}
END_OF_FILE
if test 818 -ne `wc -c <'cslib/glibrary.c'`; then
    echo shar: \"'cslib/glibrary.c'\" unpacked with wrong size!
fi
# end of 'cslib/glibrary.c'
fi
if test -f 'cslib/glibrary.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/glibrary.h'\"
else
echo shar: Extracting \"'cslib/glibrary.h'\" \(1439 characters\)
sed "s/^X//" >'cslib/glibrary.h' <<'END_OF_FILE'
X/*
X * File: glibrary.h
X * Version: 3.0
X * Last modified on Sat Oct  1 12:28:02 1994 by eroberts
X * -----------------------------------------------------
X * This interface exports several simple, low-level functions that are
X * used in various other parts of the graphics package implementation.
X * Because these functions are otherwise likely to collide with student
X * functions, all external names include a GL prefix.
X */
X
X#ifndef _glibrary_h
X#define _glibrary_h
X
X/*
X * Functions: GLRadians, GLDegrees
X * Usage: radians = GLRadians(degrees);
X *        degrees = GLDegrees(radians);
X * ------------------------------------
X * These functions convert back and forth between degrees and radians.
X */
X
Xdouble GLRadians(double degrees);
Xdouble GLDegrees(double radians);
X
X/*
X * Function: GLRound
X * Usage: n = GLRound(x);
X * ----------------------
X * This function rounds a double to the nearest integer.
X */
X
Xint GLRound(double x);
X
X/*
X * Functions: GLMin, GLMax
X * Usage: min = GLMin(x, y);
X *        max = GLMax(x, y);
X * -------------------------
X * These functions find the minimum and maximum of two integers.
X */
X
Xint GLMin(int x, int y);
Xint GLMax(int x, int y);
X
X/*
X * Functions: GLMinF, GLMaxF
X * Usage: min = GLMinF(x, y);
X *        max = GLMaxF(x, y);
X * --------------------------
X * These functions find the minimum and maximum of two doubles.
X */
X
Xdouble GLMinF(double x, double y);
Xdouble GLMaxF(double x, double y);
X
X#endif
END_OF_FILE
if test 1439 -ne `wc -c <'cslib/glibrary.h'`; then
    echo shar: \"'cslib/glibrary.h'\" unpacked with wrong size!
fi
# end of 'cslib/glibrary.h'
fi
if test -f 'cslib/graphics.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/graphics.c'\"
else
echo shar: Extracting \"'cslib/graphics.c'\" \(17740 characters\)
sed "s/^X//" >'cslib/graphics.c' <<'END_OF_FILE'
X/*
X * File: graphics.c
X * Version: 3.0
X * Last modified on Sat Oct  1 12:28:01 1994 by eroberts
X * -----------------------------------------------------
X * This file is the top-level file in the implementation of the
X * graphics.h interface for X windows.  The complete implementation
X * also includes the following subsidiary modules:
X *
X *   glibrary.h  Various low-level mathematical functions
X *   xmanager.h  Mediates communication with the X operations
X *   xdisplay.h  Performs the actual drawing operations
X *   xcompat.h   Maintains BSD compatibility on System V.
X */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <string.h>
X#include <math.h>
X#include <signal.h>
X#include <sys/time.h>
X#include <sys/types.h>
X
X#include "genlib.h"
X#include "gcalloc.h"
X#include "simpio.h"
X#include "strlib.h"
X#include "extgraph.h"
X#include "glibrary.h"
X#include "xmanager.h"
X#include "xdisplay.h"
X#include "xcompat.h"
X
X/*
X * Parameters
X * ----------
X * DesiredWidth  -- Desired width of the graphics window in inches
X * DesiredHeight -- Desired height of the graphics window in inches
X * DefaultSize   -- Default point size
X * MaxColors     -- Maximum number of color names allowed
X * MinColors     -- Minimum number of colors the device must support
X */
X
X#define DesiredWidth    7.0
X#define DesiredHeight   4.0
X#define DefaultSize    12
X#define MaxColors     256
X#define MinColors      16
X
X/*
X * Type: graphicsStateT
X * --------------------
X * This structure holds the variables that make up the graphics state.
X */
X
Xtypedef struct graphicsStateT {
X    double cx, cy;
X    string font;
X    int size;
X    int style;
X    bool erase;
X    int color;
X    struct graphicsStateT *link;
X} *graphicsStateT;
X
X/*
X * Type: regionStateT
X * ------------------
X * The region assembly process has the character of a finite state
X * machine with the following four states:
X *
X *   NoRegion       Region has not yet been started
X *   RegionStarting Region is started but no line segments yet
X *   RegionActive   First line segment appears
X *   PenHasMoved    Pen has moved during definition
X *
X * The current state determines whether other operations are legal
X * at that point.
X */
X
Xtypedef enum {
X    NoRegion, RegionStarting, RegionActive, PenHasMoved
X} regionStateT;
X
X/*
X * Type: colorEntryT
X * -----------------
X * This type is used for the entries in the color table.
X */
X
Xtypedef struct {
X    string name;
X    double red, green, blue;
X} colorEntryT;
X
X/*
X * Global variables
X * ----------------
X * initialized   -- TRUE if initialization has been done
X * windowTitle   -- Current window title (initialized statically)
X * cmdBuffer     -- Static buffer for sending commands
X * regionState   -- Current state of the region
X * colorTable    -- Table of defined colors
X * nColors       -- Number of defined colors
X * colorOK       -- TRUE if the display supports color
X * lastColor     -- Previous color to avoid multiple changes
X * fontChanged   -- TRUE if font information has changed
X * windowWidth   -- Width of the window in inches
X * windowHeight  -- Height of the window in inches
X * stateStack    -- Stack of graphicStateT blocks
X * cx, cy        -- Current coordinates     | These
X * eraseMode     -- Setting of erase flag   | variables
X * textFont      -- Current font            | consititute
X * textStyle     -- Current style           | the current
X * pointSize     -- Current point size      | graphics
X * penColor      -- Color of pen            | state
X */
X
Xstatic bool initialized = FALSE;
Xstatic string windowTitle = "Graphics Window";
X
Xstatic char cmdBuffer[CommandBufferSize];
X
Xstatic regionStateT regionState;
X
Xstatic colorEntryT colorTable[MaxColors];
Xstatic int nColors;
Xstatic bool colorOK;
Xstatic int lastColor;
Xstatic bool fontChanged;
X
Xstatic double windowWidth = DesiredWidth;
Xstatic double windowHeight = DesiredHeight;
X
Xstatic graphicsStateT stateStack;
X
Xstatic double cx, cy;
Xstatic bool eraseMode;
Xstatic string textFont;
Xstatic int textStyle;
Xstatic int pointSize;
Xstatic int penColor;
X
X/* Private function prototypes */
X
Xstatic void InitCheck(void);
Xstatic void InitGraphicsState(void);
Xstatic void InstallFont(void);
Xstatic void InitColors(void);
Xstatic int FindColorName(string name);
Xstatic bool ShouldBeWhite(void);
Xstatic bool StringMatch(string s1, string s2);
Xstatic void USleep(unsigned useconds);
X