cslib.shar

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

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/*
X * Function: RaiseException
X * Usage: RaiseException(&e, name, value);
X * ---------------------------------------
X * This function is called by the raise macro and does the
X * work necessary to raise the exception.  See the exception.c file
X * for details.  Clients do not ordinarily call this directly.
X */
X
Xvoid RaiseException(exception *e, string name, void *value);
X
X/*
X * Function: HandlerExists
X * Usage: if (HandlerExists(&e)) ...
X * ---------------------------------
X * Determines whether a handler exists for an exception in
X * the dynamically enclosing scope.  Intended only for use
X * by special clients, such as the Error package.
X */
X
Xbool HandlerExists(exception *e);
X
X/* Define the pseudo-functions for raise and try */
X
X#define raise(e) RaiseException(&e, #e, NULL)
X
X#define try \
X      { \
X          jmp_buf _jmp_; \
X          context_block _ctx_; \
X          volatile int _es_; \
X          _es_ = ES_Initialize; \
X          _ctx_.nx = 0; \
X          _ctx_.link = exceptionStack; \
X          exceptionStack = (context_block *) &_ctx_; \
X          if (setjmp(_jmp_) != 0) _es_ = ES_Exception; \
X          memcpy((void *) _ctx_.jmp, (void *) _jmp_, sizeof(jmp_buf)); \
X          while (1) { \
X              if (_es_ == ES_EvalBody)
X
X#define except(e) \
X                  if (_es_ == ES_EvalBody) exceptionStack = _ctx_.link; \
X                  break; \
X              } \
X              if (_es_ == ES_Initialize) { \
X                  if (_ctx_.nx >= MaxExceptionsPerScope) \
X                      exit(ETooManyExceptClauses); \
X                  _ctx_.array[_ctx_.nx++] = &e; \
X              } else if (_ctx_.id == &e || &e == &ANY) { \
X                  exceptionStack = _ctx_.link;
X
X#define endtry \
X              if (_es_ != ES_Initialize) break; \
X              _es_ = ES_EvalBody; \
X          } \
X      }
X
X#define GetExceptionName() _ctx_.name
X#define GetExceptionValue() _ctx_.value
X#define GetCurrentException() _ctx_.id
X
X#endif
END_OF_FILE
if test 7990 -ne `wc -c <'cslib/exception.h'`; then
    echo shar: \"'cslib/exception.h'\" unpacked with wrong size!
fi
# end of 'cslib/exception.h'
fi
if test -f 'cslib/extgraph.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/extgraph.h'\"
else
echo shar: Extracting \"'cslib/extgraph.h'\" \(14869 characters\)
sed "s/^X//" >'cslib/extgraph.h' <<'END_OF_FILE'
X/*
X * File: extgraph.h
X * Version: 3.0
X * Last modified on Tue Oct  4 11:24:41 1994 by eroberts
X * -----------------------------------------------------
X * This interface is the extended graphics interface.
X * It includes all of the facilities in graphics.h, plus
X * several additional functions that are designed to
X * support more sophisticated, interactive graphics.
X */
X
X#ifndef _extgraph_h
X#define _extgraph_h
X
X#include "genlib.h"
X
X/* Exported functions */
X
X/* Section 1 -- Basic functions from graphics.h */
X
X#include "graphics.h"
X
X/* Section 2 -- Elliptical arcs */
X
X/*
X * Function: DrawEllipticalArc
X * Usage: DrawEllipticalArc(rx, ry, start, sweep);
X * -----------------------------------------------
X * This procedure draws an elliptical arc.  It is exactly
X * the same in its operation as DrawArc in the graphics.h
X * interface, except that the radius is different along the
X * two axes.
X */
X
Xvoid DrawEllipticalArc(double rx, double ry,
X                       double start, double sweep);
X
X/* Section 3 -- Graphical regions*/
X
X/*
X * Functions: StartFilledRegion, EndFilledRegion
X * Usage: StartFilledRegion(density);
X *        . . . other calls . . .
X *        EndFilledRegion();
X * ------------------------------
X * These calls make it possible to draw filled shapes on the
X * display.  After calling StartFilledRegion, any calls to
X * DrawLine and DrawArc are used to create a shape definition
X * and do not appear on the screen until EndFilledRegion is
X * called.  The lines and arcs must be consecutive, in the
X * sense that each new element must start where the last
X * one ended.  MovePen calls may occur at the beginning
X * or the end of the region, but not in the interior. When
X * EndFilledRegion is called, the entire region appears on the
X * screen, with its interior filled in.  The density parameter
X * is a number between 0 and 1 and indicates how the dot density
X * to be used for the fill pattern.  If density is 1, the shape
X * will be filled in a solid color; if it is 0, the fill will be
X * invisible.  In between, the implementation will use a dot
X * pattern that colors some of the screen dots but not others.
X */
X
Xvoid StartFilledRegion(double density);
Xvoid EndFilledRegion(void);
X
X/* Section 4 -- String functions */
X
X/*
X * Function: DrawTextString
X * Usage: DrawTextString(text);
X * ----------------------------
X * This function displays the string text at the current point
X * in the current font and size.  The current point is updated
X * so that the next DrawTextString command would continue from
X * the next character position.  The string may not include the
X * newline character.
X */
X
Xvoid DrawTextString(string text);
X
X/*
X * Function: TextStringWidth
X * Usage: w = TextStringWidth(text);
X * ---------------------------------
X * This function returns the width of the text string if displayed
X * at the current font and size.
X */
X
Xdouble TextStringWidth(string text);
X
X/*
X * Function: SetFont
X * Usage: SetFont(font);
X * ---------------------
X * This function sets a new font according to the font string,
X * which is case-independent.  Different systems support different
X * fonts, although common ones like "Times" and "Courier" are often
X * supported.  Initially, the font is set to "Default" which is
X * always supported, although the underlying font is system
X * dependent.  If the font name is unrecognized, no error is
X * generated, and the font remains unchanged.  If you need to
X * detect this condition, you can call GetFont to see if the
X * change took effect.  By not generating an error in this case,
X * programs become more portable.
X */
X
Xvoid SetFont(string font);
X
X/*
X * Function: GetFont
X * Usage: font = GetFont();
X * ------------------------
X * This function returns the current font name as a string.
X */
X
Xstring GetFont(void);
X
X/*
X * Function: SetPointSize
X * Usage: SetPointSize(size);
X * --------------------------
X * This function sets a new point size.  If the point size is
X * not supported for a particular font, the closest existing
X * size is selected.
X */
X
Xvoid SetPointSize(int size);
X
X/*
X * Function: GetPointSize
X * Usage: size = GetPointSize();
X * -----------------------------
X * This function returns the current point size.
X */
X
Xint GetPointSize(void);
X
X/*
X * Text style constants
X * --------------------
X * The constants Bold and Italic are used in the SetStyle
X * command to specify the desired text style.  They may also
X * be used in combination by adding these constants together,
X * as in Bold + Italic.  The constant Normal indicates the
X * default style.
X */
X
X#define Normal  0
X#define Bold    1
X#define Italic  2
X
X/*
X * Function: SetStyle
X * Usage: SetStyle(style);
X * -----------------------
X * This function establishes the current style properties
X * for text based on the parameter style, which is an integer
X * representing the sum of any of the text style constants.
X */
X
Xvoid SetStyle(int style);
X
X/*
X * Function: GetStyle
X * Usage: style = GetStyle();
X * --------------------------
X * This function returns the current style.
X */
X
Xint GetStyle(void);
X
X/*
X * Functions: GetFontAscent, GetFontDescent, GetFontHeight
X * Usage: ascent = GetFontAscent();
X *        descent = GetFontDescent();
X *        height = GetFontHeight();
X * -------------------------------------------------------
X * These functions return properties of the current font that are
X * used to calculate how to position text vertically on the page.
X * The ascent of a font is the distance from the baseline to the
X * top of the largest character; the descent is the maximum
X * distance any character extends below the baseline.  The height
X * is the total distance between two lines of text, including the
X * interline space (which is called leading).
X *
X * Examples:
X *   To change the value of y so that it indicates the next text
X *   line, you need to execute
X *
X *        y -= GetFontHeight();
X *
X *   To center text vertically around the coordinate y, you need
X *   to start the pen at
X *
X *       y - GetFontAscent() / 2
X */
X
Xdouble GetFontAscent(void);
Xdouble GetFontDescent(void);
Xdouble GetFontHeight(void);
X
X/* Section 5 -- Mouse support */
X
X/*
X * Functions: GetMouseX, GetMouseY
X * Usage: x = GetMouseX();
X *        y = GetMouseY();
X * -------------------------------
X * These functions return the x and y coordinates of the mouse,
X * respectively.  The coordinate values are real numbers measured
X * in inches from the origin and therefore match the drawing
X * coordinates.
X */
X
Xdouble GetMouseX(void);
Xdouble GetMouseY(void);
X
X/*
X * Functions: MouseButtonIsDown
X * Usage: if (MouseButtonIsDown()) . . .
X * -------------------------------------
X * This function returns TRUE if the mouse button is currently
X * down.  For maximum compatibility among implementations, the
X * mouse is assumed to have one button.  If the mouse has more
X * than one button, this function returns TRUE if any button
X * is down.
X */
X
Xbool MouseButtonIsDown(void);
X
X/*
X * Functions: WaitForMouseDown, WaitForMouseUp
X * Usage: WaitForMouseDown();
X *        WaitForMouseUp();
X * -------------------------------------------
X * The WaitForMouseDown function waits until the mouse button
X * is pressed and then returns.  WaitForMouseUp waits for the
X * button to be released.
X */
X
Xvoid WaitForMouseDown(void);
Xvoid WaitForMouseUp(void);
X
X/* Section 6 -- Color support */
X
X/*
X * Function: HasColor
X * Usage: if (HasColor()) . . .
X * ----------------------------
X * This function returns TRUE if the graphics window can display a
X * color image.  Note that this condition is stronger than simply
X * checking whether a color display is available.  Because color
X * windows require more memory than black and white ones, this
X * function will return FALSE with a color screen if there is
X * not enough memory to store a colored image.  On the Macintosh,
X * for example, it is usually necessary to increase the partition
X * size to at least 1MB before color windows can be created.
X */
X
Xbool HasColor(void);
X
X/*
X * Function: SetPenColor
X * Usage: SetPenColor(color);
X * --------------------------
X * This function sets the color of the pen used for any drawing,
X * including lines, text, and filled regions.  The color is a
X * string, which will ordinarily be one of the following
X * predefined color names:
X *
X *    Black, Dark Gray, Gray, Light Gray, White,
X *    Red, Yellow, Green, Cyan, Blue, Magenta
X *
X * The first line corresponds to standard gray scales and the
X * second to the primary and secondary colors of light.  The
X * built-in set is limited to these colors because they are
X * likely to be the same on all hardware devices.  For finer
X * color control, you can use the DefineColor function to
X * create new color names as well.
X */
X
Xvoid SetPenColor(string color);
X
X/*
X * Function: GetPenColor
X * Usage: color = GetPenColor();
X * -----------------------------
X * This function returns the current pen color as a string.
X */
X
Xstring GetPenColor(void);
X
X/*
X * Function: DefineColor
X * Usage: DefineColor(name, red, green, blue);
X * -------------------------------------------
X * This function allows the client to define a new color name
X * by supplying intensity levels for the colors red, green,
X * and blue, which are the primary colors of light.  The
X * color values are provided as real numbers between 0 and 1,
X * indicating the intensity of that color.  For example,
X * the predefined color Magenta has full intensity red and
X * blue but no green and is therefore defined as:
X *
X *      DefineColor("Magenta", 1, 0, 1);
X *
X * DefineColor allows you to create intermediate colors on
X * many displays, although the results vary significantly
X * depending on the hardware.  For example, the following
X * usually gives a reasonable approximation of brown:
X *
X *      DefineColor("Brown", .35, .20, .05);
X */
X
Xvoid DefineColor(string name,
X                 double red, double green, double blue);
X
X/* Section 7 -- Miscellaneous functions */
X