standard.shar

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

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/graphics.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/graphics.c'\"
else
echo shar: Extracting \"'cslib/graphics.c'\" \(4864 characters\)
sed "s/^X//" >'cslib/graphics.c' <<'END_OF_FILE'
X/*
X * File: graphics.c
X * Version: 1.0
X * Last modified on Thu Sep 16 09:34:19 1993 by eroberts
X * -----------------------------------------------------
X * This file provides a fully standard implementation of the
X * graphics.h interface that generates a PostScript file,
X * suitable for printing.  None of the operations in the
X * extended graphics interface are supported.  PostScript is
X * a registered trademark of Adobe Systems Incorporated.
X */
X
X/*
X * General implementation notes
X * ----------------------------
X * This implementation of the graphics.h interface does not
X * actually do any display but instead writes a PostScript
X * file containing commands that would generate the picture.
X * The advantage of this implementation is portability, since
X * it contains no code that depends on graphics primitives
X * for a particular platform.
X *
X * The code for this implementation is for the most part
X * straightforward, because all of the graphics primitives
X * have simple PostScript equivalents.  The only hard part
X * is making sure that the end of the file is correct when
X * the file is closed, usually via the exit call.  To print
X * the page, the showpage command must occur at the end of
X * the file, but the graphics package does not get control
X * at that point.  To avoid the problem, each call to this
X * package writes a legal trailer to the file.  Thus, the
X * invariant after each call to any of these functions is
X * that the PostScript file is complete.  Before writing
X * new data, these functions back up the file pointer over
X * the old trailer and begin rewriting from that point.
X */
X
X#include <stdio.h>
X#include <math.h>
X
X#include "genlib.h"
X#include "graphics.h"
X
X/*
X * Constants: WindowHeight, WindowWidth
X * ------------------------------------
X * These constants are the values returned by GetWindowHeight
X * and GetWindowWidth.  The assumption here is that output is
X * being directed to an 8.5 x 11 page.
X */
X
X#define WindowHeight 11.0
X#define WindowWidth   8.5
X
X/*
X * Constant: PSFileName
X * --------------------
X * The name of the PostScript output file.
X */
X
X#define PSFileName "graphics.ps"
X
X/*
X * Private variables
X * -----------------
X * initialized    Set to TRUE when InitGraphics is called.
X * psfile         The file stream used for PostScript.
X * cx, cy         The current x, y positions.
X * nextWrite      The file index for the next PostScript
X *                command (see the general notes above).
X */
X
Xstatic bool initialized = FALSE;
X
Xstatic FILE *psfile;
X
Xstatic double cx, cy;
X
Xstatic long nextWrite;
X
X/* Private function prototypes */
X
Xstatic void InitCheck(void);
Xstatic void WritePostScriptHeader(void);
Xstatic void WritePostScriptTrailer(void);
Xstatic void ResetFilePointer(void);
Xstatic double Pts(double inches);
Xstatic double Radians(double degrees);
X
X/* Public functions */
X
Xvoid InitGraphics(void)
X{
X    if (initialized) fclose(psfile);
X    psfile = fopen(PSFileName, "w");
X    WritePostScriptHeader();
X    WritePostScriptTrailer();
X    cx = cy = 0;
X    initialized = TRUE;
X}
X
Xvoid MovePen(double x, double y)
X{
X    InitCheck();
X    cx = x;
X    cy = y;
X}
X
Xvoid DrawLine(double dx, double dy)
X{
X    InitCheck();
X    ResetFilePointer();
X    fprintf(psfile, "newpath %g %g moveto", Pts(cx), Pts(cy));
X    fprintf(psfile, " %g %g rlineto stroke\n", Pts(dx), Pts(dy));
X    cx += dx;
X    cy += dy;
X    WritePostScriptTrailer();
X}
X
Xvoid DrawArc(double r, double start, double sweep)
X{
X    double x, y;
X
X    InitCheck();
X    x = cx + r * cos(Radians(start + 180));
X    y = cy + r * sin(Radians(start + 180));
X    ResetFilePointer();
X    fprintf(psfile, "newpath %g %g %g", Pts(x), Pts(y), Pts(r));
X    fprintf(psfile, " %g %g", start, start + sweep);
X    fprintf(psfile, " %s stroke\n", (sweep < 0) ? "arcn" : "arc");
X    WritePostScriptTrailer();
X    cx = x + r * cos(Radians(start + sweep));
X    cy = y + r * sin(Radians(start + sweep));
X}
X
Xdouble GetWindowWidth(void)
X{
X    InitCheck();
X    return (WindowWidth);
X}
X
Xdouble GetWindowHeight(void)
X{
X    InitCheck();
X    return (WindowHeight);
X}
X
Xdouble GetCurrentX(void)
X{
X    InitCheck();
X    return (cx);
X}
X
Xdouble GetCurrentY(void)
X{
X    InitCheck();
X    return (cy);
X}
X
X/* Private functions */
X
Xstatic void InitCheck(void)
X{
X    if (!initialized) Error("InitGraphics has not been called");
X}
X
Xstatic void WritePostScriptHeader(void)
X{
X    fprintf(psfile, "%%!PS-Adobe-1.0\n");
X    fprintf(psfile, "%%%%Title: graphics window\n");
X    fprintf(psfile, "%%%%Pages: 1\n");
X    fprintf(psfile, "%%%%EndComments\n");
X}
X
Xstatic void WritePostScriptTrailer(void)
X{
X    nextWrite = ftell(psfile);
X    fprintf(psfile, "showpage\n");
X}
X
Xstatic void ResetFilePointer(void)
X{
X    fseek(psfile, nextWrite, 0);
X}
X
Xstatic double Pts(double inches)
X{
X    return (72 * inches);
X}
X
Xstatic double Radians(double degrees)
X{
X    return (degrees / 180 * 3.1415926535);
X}
END_OF_FILE
if test 4864 -ne `wc -c <'cslib/graphics.c'`; then
    echo shar: \"'cslib/graphics.c'\" unpacked with wrong size!
fi
# end of 'cslib/graphics.c'
fi
if test -f 'cslib/graphics.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/graphics.h'\"
else
echo shar: Extracting \"'cslib/graphics.h'\" \(4805 characters\)
sed "s/^X//" >'cslib/graphics.h' <<'END_OF_FILE'
X/*
X * File: graphics.h
X * Version: 1.0
X * Last modified on Mon Jun  6 11:03:27 1994 by eroberts
X * -----------------------------------------------------
X * This interface provides access to a simple library of
X * functions that make it possible to draw lines and arcs
X * on the screen.  This interface presents a portable
X * abstraction that can be used with a variety of window
X * systems implemented on different hardware platforms.
X */
X
X#ifndef _graphics_h
X#define _graphics_h
X
X/*
X * Overview
X * --------
X * This library provides several functions for drawing lines
X * and circular arcs in a region of the screen that is
X * defined as the "graphics window."  Once drawn, these
X * lines and arcs stay in their position, which means that
X * the package can only be used for static pictures and not
X * for animation.
X *
X * Individual points within the window are specified by
X * giving their x and y coordinates.  These coordinates are
X * real numbers measured in inches, with the origin in the
X * lower left corner, as it is in traditional mathematics.
X *
X * The calls available in the package are listed below.  More
X * complete descriptions are included with each function
X * description.
X *
X *   InitGraphics();
X *   MovePen(x, y);
X *   DrawLine(dx, dy);
X *   DrawArc(r, start, sweep);
X *   width = GetWindowWidth();
X *   height = GetWindowHeight();
X *   x = GetCurrentX();
X *   y = GetCurrentY();
X */
X
X/*
X * Function: InitGraphics
X * Usage: InitGraphics();
X * ----------------------
X * This procedure creates the graphics window on the screen.
X * The call to InitGraphics must precede any calls to other
X * functions in this package and must also precede any printf
X * output.  In most cases, the InitGraphics call is the first
X * statement in the function main.
X */
X
Xvoid InitGraphics(void);
X
X/*
X * Function: MovePen
X * Usage: MovePen(x, y);
X * ---------------------
X * This procedure moves the current point to the position
X * (x, y), without drawing a line.  The model is that of
X * the pen being lifted off the graphics window surface and
X * then moved to its new position.
X */
X
Xvoid MovePen(double x, double y);
X
X/*
X * Function: DrawLine
X * Usage: DrawLine(dx, dy);
X * ------------------------
X * This procedure draws a line extending from the current
X * point by moving the pen dx inches in the x direction
X * and dy inches in the y direction.  The final position
X * becomes the new current point.
X */
X
Xvoid DrawLine(double dx, double dy);
X
X/*
X * Function: DrawArc
X * Usage: DrawArc(r, start, sweep);
X * --------------------------------
X * This procedure draws a circular arc, which always begins
X * at the current point.  The arc itself has radius r, and
X * starts at the angle specified by the parameter start,
X * relative to the center of the circle.  This angle is
X * measured in degrees counterclockwise from the 3 o'clock
X * position along the x-axis, as in traditional mathematics.
X * For example, if start is 0, the arc begins at the 3 o'clock
X * position; if start is 90, the arc begins at the 12 o'clock
X * position; and so on.  The fraction of the circle drawn is
X * specified by the parameter sweep, which is also measured in
X * degrees.  If sweep is 360, DrawArc draws a complete circle;
X * if sweep is 90, it draws a quarter of a circle.  If the value
X * of sweep is positive, the arc is drawn counterclockwise from
X * the current point.  If sweep is negative, the arc is drawn
X * clockwise from the current point.  The current point at the
X * end of the DrawArc operation is the final position of the pen
X * along the arc.
X *
X * Examples:
X *   DrawArc(r, 0, 360)    Draws a circle to the left of the
X *                         current point.
X *   DrawArc(r, 90, 180)   Draws the left half of a semicircle
X *                         starting from the 12 o'clock position.
X *   DrawArc(r, 0, 90)     Draws a quarter circle from the 3
X *                         o'clock to the 12 o'clock position.
X *   DrawArc(r, 0, -90)    Draws a quarter circle from the 3
X *                         o'clock to the 6 o'clock position.
X *   DrawArc(r, -90, -90)  Draws a quarter circle from the 6
X *                         o'clock to the 9 o'clock position.
X */
X
Xvoid DrawArc(double r, double start, double sweep);
X
X/*
X * Functions: GetWindowWidth, GetWindowHeight
X * Usage: width = GetWindowWidth();
X *        height = GetWindowHeight();
X * ------------------------------------------
X * These functions return the width and height of the graphics
X * window, in inches.
X */
X
Xdouble GetWindowWidth(void);
Xdouble GetWindowHeight(void);
X
X/*
X * Functions: GetCurrentX, GetCurrentY
X * Usage: x = GetCurrentX();
X *        y = GetCurrentY();
X * -----------------------------------
X * These functions return the current x and y positions.
X */
X
Xdouble GetCurrentX(void);
Xdouble GetCurrentY(void);
X
X#endif
END_OF_FILE
if test 4805 -ne `wc -c <'cslib/graphics.h'`; then
    echo shar: \"'cslib/graphics.h'\" unpacked with wrong size!
fi
# end of 'cslib/graphics.h'
fi
if test -f 'cslib/random.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/random.c'\"
else
echo shar: Extracting \"'cslib/random.c'\" \(1718 characters\)
sed "s/^X//" >'cslib/random.c' <<'END_OF_FILE'
X/*
X * File: random.c
X * Version: 1.0
X * Last modified on Mon Sep 13 10:42:45 1993 by eroberts
X * -----------------------------------------------------
X * This file implements the random.h interface.
X */
X
X#include <stdio.h>
X#include <stdlib.h>
X#include <time.h>
X
X#include "genlib.h"
X#include "random.h"
X
X/*
X * Function: Randomize
X * -------------------
X * This function operates by setting the random number
X * seed to the current time.  The srand function is