From 7eb38fea596969878a33f30e36fe33b125f9c4bd Mon Sep 17 00:00:00 2001 From: dos-reis Date: Sun, 2 Sep 2007 21:56:58 +0000 Subject: * XSpadFill.c: New. Replace corresponding pamphlet. * XSpadFill.c.pamphlet: Remove. * XShade.c: New. Replace corresponding pamphlet. * XShade.c.pamphlet: Remove. * XDither.c: New. Replace corresponding pamphlet. * XDither.c.pamphlet: Remove. * wct.c: New. Replace corresponding pamphlet. * wct.c.pamphlet: Remove. * util.c: New. Replace corresponding pamphlet. * util.c.pamphlet: Remove. * spadcolors.c: New. Replace corresponding pamphlet. * spadcolors.c.pamphlet: Remove. * sockio-c.c: New. Replace corresponding pamphlet. * sockio-c.c.pamphlet: Remove. * prt.c: New. Replace corresponding pamphlet. * prt.c.pamphlet: Remove. * pixmap.c: New. Replace corresponding pamphlet. * pixmap.c.pamphlet: Remove. * openpty.c: New. Replace corresponding pamphlet. * openpty.c.pamphlet: Remove. * hash.c: New. Replace corresponding pamphlet. * hash.c.pamphlet: Remove. * halloc.c: New. Replace corresponding pamphlet. * halloc.c.pamphlet: Remove. * fnct_key.c: New. Replace corresponding pamphlet. * fnct_key.c.pamphlet: Remove. * edin.c: New. Replace corresponding pamphlet. * edin.c.pamphlet: Remove. * bsdsignal.c: New. Replace correponding pamphlet. * bsdsignal.c.pamphlet: Remove. * cursor.c: New. Replace corresponding pamphlet. * cursor.c.pamphlet: Remove. * cfuns-c.c: New. Replace corresponding pamphlet. * cfuns-c.c.pamphlet: Remove. --- src/lib/ChangeLog | 37 ++ src/lib/Makefile.in | 31 +- src/lib/Makefile.pamphlet | 55 +- src/lib/XDither.c | 232 ++++++++ src/lib/XDither.c.pamphlet | 254 --------- src/lib/XShade.c | 214 ++++++++ src/lib/XShade.c.pamphlet | 236 -------- src/lib/XSpadFill.c | 300 ++++++++++ src/lib/XSpadFill.c.pamphlet | 321 ----------- src/lib/bsdsignal.c | 71 +++ src/lib/bsdsignal.c.pamphlet | 320 ----------- src/lib/cfuns-c.c | 265 +++++++++ src/lib/cfuns-c.c.pamphlet | 285 ---------- src/lib/cursor.c | 142 +++++ src/lib/cursor.c.pamphlet | 164 ------ src/lib/edin.c | 941 +++++++++++++++++++++++++++++++ src/lib/edin.c.pamphlet | 971 -------------------------------- src/lib/fnct_key.c | 357 ++++++++++++ src/lib/fnct_key.c.pamphlet | 395 ------------- src/lib/halloc.c | 57 ++ src/lib/halloc.c.pamphlet | 79 --- src/lib/hash.c | 219 ++++++++ src/lib/hash.c.pamphlet | 240 -------- src/lib/openpty.c | 192 +++++++ src/lib/openpty.c.pamphlet | 226 -------- src/lib/pixmap.c | 321 +++++++++++ src/lib/pixmap.c.pamphlet | 352 ------------ src/lib/prt.c | 407 ++++++++++++++ src/lib/prt.c.pamphlet | 429 --------------- src/lib/sockio-c.c | 1191 ++++++++++++++++++++++++++++++++++++++++ src/lib/sockio-c.c.pamphlet | 1218 ----------------------------------------- src/lib/spadcolors.c | 533 ++++++++++++++++++ src/lib/spadcolors.c.pamphlet | 618 --------------------- src/lib/util.c | 162 ++++++ src/lib/util.c.pamphlet | 192 ------- src/lib/wct.c | 738 +++++++++++++++++++++++++ src/lib/wct.c.pamphlet | 768 -------------------------- 37 files changed, 6401 insertions(+), 7132 deletions(-) create mode 100644 src/lib/XDither.c delete mode 100644 src/lib/XDither.c.pamphlet create mode 100644 src/lib/XShade.c delete mode 100644 src/lib/XShade.c.pamphlet create mode 100644 src/lib/XSpadFill.c delete mode 100644 src/lib/XSpadFill.c.pamphlet create mode 100644 src/lib/bsdsignal.c delete mode 100644 src/lib/bsdsignal.c.pamphlet create mode 100644 src/lib/cfuns-c.c delete mode 100644 src/lib/cfuns-c.c.pamphlet create mode 100644 src/lib/cursor.c delete mode 100644 src/lib/cursor.c.pamphlet create mode 100644 src/lib/edin.c delete mode 100644 src/lib/edin.c.pamphlet create mode 100644 src/lib/fnct_key.c delete mode 100644 src/lib/fnct_key.c.pamphlet create mode 100644 src/lib/halloc.c delete mode 100644 src/lib/halloc.c.pamphlet create mode 100644 src/lib/hash.c delete mode 100644 src/lib/hash.c.pamphlet create mode 100644 src/lib/openpty.c delete mode 100644 src/lib/openpty.c.pamphlet create mode 100644 src/lib/pixmap.c delete mode 100644 src/lib/pixmap.c.pamphlet create mode 100644 src/lib/prt.c delete mode 100644 src/lib/prt.c.pamphlet create mode 100644 src/lib/sockio-c.c delete mode 100644 src/lib/sockio-c.c.pamphlet create mode 100644 src/lib/spadcolors.c delete mode 100644 src/lib/spadcolors.c.pamphlet create mode 100644 src/lib/util.c delete mode 100644 src/lib/util.c.pamphlet create mode 100644 src/lib/wct.c delete mode 100644 src/lib/wct.c.pamphlet (limited to 'src/lib') diff --git a/src/lib/ChangeLog b/src/lib/ChangeLog index 8bcace53..3104d00b 100644 --- a/src/lib/ChangeLog +++ b/src/lib/ChangeLog @@ -1,3 +1,40 @@ +2007-09-02 Gabriel Dos Reis + + * XSpadFill.c: New. Replace corresponding pamphlet. + * XSpadFill.c.pamphlet: Remove. + * XShade.c: New. Replace corresponding pamphlet. + * XShade.c.pamphlet: Remove. + * XDither.c: New. Replace corresponding pamphlet. + * XDither.c.pamphlet: Remove. + * wct.c: New. Replace corresponding pamphlet. + * wct.c.pamphlet: Remove. + * util.c: New. Replace corresponding pamphlet. + * util.c.pamphlet: Remove. + * spadcolors.c: New. Replace corresponding pamphlet. + * spadcolors.c.pamphlet: Remove. + * sockio-c.c: New. Replace corresponding pamphlet. + * sockio-c.c.pamphlet: Remove. + * prt.c: New. Replace corresponding pamphlet. + * prt.c.pamphlet: Remove. + * pixmap.c: New. Replace corresponding pamphlet. + * pixmap.c.pamphlet: Remove. + * openpty.c: New. Replace corresponding pamphlet. + * openpty.c.pamphlet: Remove. + * hash.c: New. Replace corresponding pamphlet. + * hash.c.pamphlet: Remove. + * halloc.c: New. Replace corresponding pamphlet. + * halloc.c.pamphlet: Remove. + * fnct_key.c: New. Replace corresponding pamphlet. + * fnct_key.c.pamphlet: Remove. + * edin.c: New. Replace corresponding pamphlet. + * edin.c.pamphlet: Remove. + * bsdsignal.c: New. Replace correponding pamphlet. + * bsdsignal.c.pamphlet: Remove. + * cursor.c: New. Replace corresponding pamphlet. + * cursor.c.pamphlet: Remove. + * cfuns-c.c: New. Replace corresponding pamphlet. + * cfuns-c.c.pamphlet: Remove. + 2007-08-17 Gabriel Dos Reis * Makefile.pamphlet ($(axiom_target_libdir)/libspad.la): Remove diff --git a/src/lib/Makefile.in b/src/lib/Makefile.in index 09d7ea2b..05045445 100644 --- a/src/lib/Makefile.in +++ b/src/lib/Makefile.in @@ -1,6 +1,6 @@ -core_sources = bsdsignal.c cfuns-c.c sockio-c.c -terminal_io_sources = cursor.c edin.c fnct_key.c openpty.c prt.c wct.c -graphics_sources = \ +core_SOURCES = bsdsignal.c cfuns-c.c sockio-c.c +terminal_io_SOURCES = cursor.c edin.c fnct_key.c openpty.c prt.c wct.c +graphics_SOURCES = \ halloc.c \ hash.c \ pixmap.c \ @@ -10,23 +10,19 @@ graphics_sources = \ XShade.c \ XSpadFill.c -libspad_la_sources = $(foreach comp, \ - $(addsuffix _sources, @axiom_c_runtime@), \ +libspad_la_SOURCES = $(foreach comp, \ + $(addsuffix _SOURCES, @axiom_c_runtime@), \ $($(comp))) -libspad_la_SOURCES = $(addsuffix .pamphlet,$(libspad_la_sources)) +other_SOURCES = cfuns-c.c -other_sources = cfuns-c.c +unused_SOURCES = emupty.c -other_SOURCES = $(addsuffix .pamphlet,$(other_sources)) +libspad_la_objects = $(libspad_la_SOURCES:.c=.lo) -unused_sources = emupty.c +other_objects = $(other_SOURCES:.c=.$(OBJEXT)) -libspad_la_objects = $(libspad_la_sources:.c=.lo) - -other_objects = $(other_sources:.c=.$(OBJEXT)) - -pamphlets = Makefile.pamphlet $(libspad_la_SOURCES) $(other_SOURCES) +pamphlets = Makefile.pamphlet subdir = src/lib/ @@ -46,11 +42,6 @@ $(axiom_target_libdir)/libspad.la: $(libspad_la_objects) $(LIBTOOL) --mode=link $(CC) -o $@ $(libspad_la_objects) \ -rpath $(libdir)/axiom/target/$(target)/lib -.PRECIOUS: %.c - -%.c: $(srcdir)/%.c.pamphlet - $(axiom_build_document) --tangle --output=$@ $< - .PRECIOUS: %.$(OBJEXT) %.lo %.lo: %.c $(axiom_c_macros_h) @@ -65,7 +56,7 @@ mostlyclean-local: clean-local: mostlyclean-local @$(LIBTOOL) --mode=clean $(axiom_target_libdir)/libspad.la @rm -f $(other_objects) - @rm -f $(libspad_la_sources) $(other_sources) + @rm -f $(libspad_la_SOURCES) $(other_SOURCES) @rm -fr .libs _libs @rm -f stamp diff --git a/src/lib/Makefile.pamphlet b/src/lib/Makefile.pamphlet index 6b0b0433..3dc252e9 100644 --- a/src/lib/Makefile.pamphlet +++ b/src/lib/Makefile.pamphlet @@ -40,7 +40,7 @@ they depend on [[]], [[]], and [[]] <>= -core_sources = bsdsignal.c cfuns-c.c sockio-c.c +core_SOURCES = bsdsignal.c cfuns-c.c sockio-c.c @ @@ -50,7 +50,7 @@ This component provides all the routines necessary to build the \Tool{Superman} component. <>= -terminal_io_sources = cursor.c edin.c fnct_key.c openpty.c prt.c wct.c +terminal_io_SOURCES = cursor.c edin.c fnct_key.c openpty.c prt.c wct.c @ @@ -59,7 +59,7 @@ terminal_io_sources = cursor.c edin.c fnct_key.c openpty.c prt.c wct.c HyperDoc and any other graphics capability. <>= -graphics_sources = \ +graphics_SOURCES = \ halloc.c \ hash.c \ pixmap.c \ @@ -81,35 +81,23 @@ It is a list of the main components. It also contain [[core]] <>= -libspad_la_sources = $(foreach comp, \ - $(addsuffix _sources, @axiom_c_runtime@), \ +libspad_la_SOURCES = $(foreach comp, \ + $(addsuffix _SOURCES, @axiom_c_runtime@), \ $($(comp))) -libspad_la_SOURCES = $(addsuffix .pamphlet,$(libspad_la_sources)) +other_SOURCES = cfuns-c.c -other_sources = cfuns-c.c +unused_SOURCES = emupty.c -other_SOURCES = $(addsuffix .pamphlet,$(other_sources)) +libspad_la_objects = $(libspad_la_SOURCES:.c=.lo) -unused_sources = emupty.c +other_objects = $(other_SOURCES:.c=.$(OBJEXT)) -libspad_la_objects = $(libspad_la_sources:.c=.lo) - -other_objects = $(other_sources:.c=.$(OBJEXT)) - -pamphlets = Makefile.pamphlet $(libspad_la_SOURCES) $(other_SOURCES) +pamphlets = Makefile.pamphlet @ \section{Files} -\subsection{C from pamphlet} -<>= -.PRECIOUS: %.c - -%.c: $(srcdir)/%.c.pamphlet - $(axiom_build_document) --tangle --output=$@ $< -@ - \subsection{object from C} <>= .PRECIOUS: %.$(OBJEXT) %.lo @@ -150,7 +138,7 @@ mostlyclean-local: clean-local: mostlyclean-local @$(LIBTOOL) --mode=clean $(axiom_target_libdir)/libspad.la @rm -f $(other_objects) - @rm -f $(libspad_la_sources) $(other_sources) + @rm -f $(libspad_la_SOURCES) $(other_SOURCES) @rm -fr .libs _libs @rm -f stamp @@ -178,30 +166,9 @@ $(axiom_target_libdir)/libspad.la: $(libspad_la_objects) $(LIBTOOL) --mode=link $(CC) -o $@ $(libspad_la_objects) \ -rpath $(libdir)/axiom/target/$(target)/lib -<> - <> <> @ -\eject -\begin{thebibliography}{99} -\bibitem{1} {\$SPAD/src/lib/bsdssignal.c.pamphlet} -\bibitem{2} {\$SPAD/src/lib/cfuns-c.c.pamphlet} -\bibitem{3} {\$SPAD/src/lib/cursor.c.pamphlet} -\bibitem{4} {\$SPAD/src/lib/edin.c.pamphlet} -\bibitem{5} {\$SPAD/src/lib/fnct\_key.c.pamphlet} -\bibitem{6} {\$SPAD/src/lib/halloc.c.pamphlet} -\bibitem{7} {\$SPAD/src/lib/openpty.c.pamphlet} -\bibitem{8} {\$SPAD/src/lib/pixmap.c.pamphlet} -\bibitem{9} {\$SPAD/src/lib/prt.c.pamphlet} -\bibitem{10} {\$SPAD/src/lib/sockio-c.c.pamphlet} -\bibitem{11} {\$SPAD/src/lib/spadcolors.c.pamphlet} -\bibitem{12} {\$SPAD/src/lib/util.c.pamphlet} -\bibitem{13} {\$SPAD/src/lib/wct.c.pamphlet} -\bibitem{14} {\$SPAD/src/lib/XDither.c.pamphlet} -\bibitem{15} {\$SPAD/src/lib/XShade.c.pamphlet} -\bibitem{16} {\$SPAD/src/lib/XSpadFill.c.pamphlet} -\end{thebibliography} \end{document} diff --git a/src/lib/XDither.c b/src/lib/XDither.c new file mode 100644 index 00000000..ab2a84b6 --- /dev/null +++ b/src/lib/XDither.c @@ -0,0 +1,232 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" +#ifndef MSYSplatform + +#include +#include +#if !defined(BSDplatform) +#include +#endif + +#include +#include +#include +#include +#include +#include + +#define XDitherWidth 3 +#define XDitherMax 10 + +char XDitherBits[] = { + 0x00, 0x00, 0x00, + 0x00, 0x02, 0x00, + 0x00, 0x03, 0x00, + 0x00, 0x03, 0x02, + 0x00, 0x07, 0x02, + 0x04, 0x07, 0x02, + 0x04, 0x07, 0x03, + 0x05, 0x07, 0x03, + 0x05, 0x07, 0x07, + 0x07, 0x07, 0x07 }; + +#include "XDither.H1" + +Pixmap XDither[XDitherMax]; +unsigned int DITHERINIT = 0; + + + +/* + * This routine has the function of returning the number of characters needed + * to store a bitmap. It first calculates the number of bits needed per line. + * Then it finds the closest multiple of 8 which is bigger than the number of + * bits. Once that is done, it multiplies this number by the number of bits + * high the bitmap is. + */ +int +dither_char_bitmap(void) +{ + int bits_line; + int total_chars; + + for (bits_line = 8, total_chars = 1; bits_line < XDitherWidth; total_chars++) + bits_line += 8; + + total_chars = total_chars * XDitherWidth; + + return total_chars; +} + +int +XInitDither(Display *display, int screen, GC gc, unsigned long fg, + unsigned long bg) +{ + + char *bits; + int count; + int chars_bitmap = dither_char_bitmap(); + int bit; + XGCValues xgcv; + + DITHERINIT = 1; + + /* + * First thing I should do is load in the Pixmaps + */ + bits = (char *) malloc(chars_bitmap * sizeof(char)); + + for (count = 0; count < XDitherMax; count++) { + + /* + * Load in the next bitmap + */ + for (bit = 0; bit < chars_bitmap; bit++) + bits[bit] = XDitherBits[count * chars_bitmap + bit]; + + /* + * Create it and put it into the Pixmap array + */ + XDither[count] = XCreatePixmapFromBitmapData(display, + RootWindow(display, screen), + bits, + XDitherWidth, XDitherWidth, + BlackPixel(display, screen), + WhitePixel(display, screen), + 1); + } + + /* + * Now reset the gc values to be as I need them + */ + xgcv.background = bg; + xgcv.foreground = fg; + xgcv.fill_style = FillOpaqueStippled; + xgcv.stipple = XDither[4]; + + XChangeGC(display, gc, + GCForeground | GCBackground | GCFillStyle | GCStipple, &xgcv); + + return (XDitherMax); + +} + + +int +XChangeDither(Display *display, GC gc, int dither) +{ + if (!DITHERINIT) { + fprintf(stderr, "XChange Error: Init Not Called\n"); + exit(-1); + } + if (dither >= XDitherMax || dither < 0) { + fprintf(stderr, "Dither %d, out of range\n",dither); + return (-1); + } + XSetStipple(display, gc, XDither[dither]); + return (1); +} + + +void +XDitherRectangle(Display *display, Drawable drawable, GC gc, int x, + int y, unsigned int width, unsigned int height) +{ + + + if (!DITHERINIT) { + fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillRectangle(display, drawable, gc, x, y, width, height); + +} + + +void +XDitherRectangles(Display *display, Drawable drawable, GC gc, + XRectangle *rectangles, int nrectangles) +{ + + + if (!DITHERINIT) { + fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillRectangles(display, drawable, gc, + rectangles, nrectangles); + +} + + +void +XDitherPolygon(Display * display, Drawable drawable, GC gc, + XPoint *points, int npoints, int shape, int mode) +{ + if (!DITHERINIT) { + fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); + exit(-1); + } + + XFillPolygon(display, drawable, gc, + points, npoints, shape, mode); + +} + +void +XDitherArc(Display *display, Drawable drawable, GC gc, int x,int y, + unsigned int width, unsigned int height, int angle1, int angle2) +{ + + if (!DITHERINIT) { + fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillArc(display, drawable, gc, x, y, width, + height, angle1, angle2); +} + + +void +XDitherArcs(Display *display,Drawable drawable, GC gc, XArc *arcs,int narcs) +{ + + if (!DITHERINIT) { + fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillArcs(display, drawable, gc, arcs, narcs); +} +#endif /* MSYSplatform */ diff --git a/src/lib/XDither.c.pamphlet b/src/lib/XDither.c.pamphlet deleted file mode 100644 index 8344a584..00000000 --- a/src/lib/XDither.c.pamphlet +++ /dev/null @@ -1,254 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib XDither.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -#ifndef MSYSplatform - -#include -#include -#if !defined(BSDplatform) -#include -#endif - -#include -#include -#include -#include -#include -#include - -#define XDitherWidth 3 -#define XDitherMax 10 - -char XDitherBits[] = { - 0x00, 0x00, 0x00, - 0x00, 0x02, 0x00, - 0x00, 0x03, 0x00, - 0x00, 0x03, 0x02, - 0x00, 0x07, 0x02, - 0x04, 0x07, 0x02, - 0x04, 0x07, 0x03, - 0x05, 0x07, 0x03, - 0x05, 0x07, 0x07, - 0x07, 0x07, 0x07 }; - -#include "XDither.H1" - -Pixmap XDither[XDitherMax]; -unsigned int DITHERINIT = 0; - - - -/* - * This routine has the function of returning the number of characters needed - * to store a bitmap. It first calculates the number of bits needed per line. - * Then it finds the closest multiple of 8 which is bigger than the number of - * bits. Once that is done, it multiplies this number by the number of bits - * high the bitmap is. - */ -int -dither_char_bitmap(void) -{ - int bits_line; - int total_chars; - - for (bits_line = 8, total_chars = 1; bits_line < XDitherWidth; total_chars++) - bits_line += 8; - - total_chars = total_chars * XDitherWidth; - - return total_chars; -} - -int -XInitDither(Display *display, int screen, GC gc, unsigned long fg, - unsigned long bg) -{ - - char *bits; - int count; - int chars_bitmap = dither_char_bitmap(); - int bit; - XGCValues xgcv; - - DITHERINIT = 1; - - /* - * First thing I should do is load in the Pixmaps - */ - bits = (char *) malloc(chars_bitmap * sizeof(char)); - - for (count = 0; count < XDitherMax; count++) { - - /* - * Load in the next bitmap - */ - for (bit = 0; bit < chars_bitmap; bit++) - bits[bit] = XDitherBits[count * chars_bitmap + bit]; - - /* - * Create it and put it into the Pixmap array - */ - XDither[count] = XCreatePixmapFromBitmapData(display, - RootWindow(display, screen), - bits, - XDitherWidth, XDitherWidth, - BlackPixel(display, screen), - WhitePixel(display, screen), - 1); - } - - /* - * Now reset the gc values to be as I need them - */ - xgcv.background = bg; - xgcv.foreground = fg; - xgcv.fill_style = FillOpaqueStippled; - xgcv.stipple = XDither[4]; - - XChangeGC(display, gc, - GCForeground | GCBackground | GCFillStyle | GCStipple, &xgcv); - - return (XDitherMax); - -} - - -int -XChangeDither(Display *display, GC gc, int dither) -{ - if (!DITHERINIT) { - fprintf(stderr, "XChange Error: Init Not Called\n"); - exit(-1); - } - if (dither >= XDitherMax || dither < 0) { - fprintf(stderr, "Dither %d, out of range\n",dither); - return (-1); - } - XSetStipple(display, gc, XDither[dither]); - return (1); -} - - -void -XDitherRectangle(Display *display, Drawable drawable, GC gc, int x, - int y, unsigned int width, unsigned int height) -{ - - - if (!DITHERINIT) { - fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillRectangle(display, drawable, gc, x, y, width, height); - -} - - -void -XDitherRectangles(Display *display, Drawable drawable, GC gc, - XRectangle *rectangles, int nrectangles) -{ - - - if (!DITHERINIT) { - fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillRectangles(display, drawable, gc, - rectangles, nrectangles); - -} - - -void -XDitherPolygon(Display * display, Drawable drawable, GC gc, - XPoint *points, int npoints, int shape, int mode) -{ - if (!DITHERINIT) { - fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); - exit(-1); - } - - XFillPolygon(display, drawable, gc, - points, npoints, shape, mode); - -} - -void -XDitherArc(Display *display, Drawable drawable, GC gc, int x,int y, - unsigned int width, unsigned int height, int angle1, int angle2) -{ - - if (!DITHERINIT) { - fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillArc(display, drawable, gc, x, y, width, - height, angle1, angle2); -} - - -void -XDitherArcs(Display *display,Drawable drawable, GC gc, XArc *arcs,int narcs) -{ - - if (!DITHERINIT) { - fprintf(stderr, "XDither Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillArcs(display, drawable, gc, arcs, narcs); -} -#endif /* MSYSplatform */ -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/XShade.c b/src/lib/XShade.c new file mode 100644 index 00000000..2a89a493 --- /dev/null +++ b/src/lib/XShade.c @@ -0,0 +1,214 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" +#ifndef MSYSplatform + +#include +#if !defined(BSDplatform) +#include +#endif +#include + +#include +#include +#include +#include +#include +#include + +#define XShadeWidth 4 +#define XShadeMax 17 + +char XShadeBits[] = { + 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x04, 0x00, + 0x05, 0x00, 0x04, 0x00, + 0x05, 0x00, 0x05, 0x00, + 0x05, 0x02, 0x05, 0x00, + 0x05, 0x02, 0x05, 0x08, + 0x05, 0x0a, 0x05, 0x08, + 0x05, 0x0a, 0x05, 0x0a, + 0x07, 0x0a, 0x05, 0x0a, + 0x07, 0x0a, 0x0d, 0x0a, + 0x0f, 0x0a, 0x0d, 0x0a, + 0x0f, 0x0a, 0x0f, 0x0a, + 0x0f, 0x0b, 0x0f, 0x0a, + 0x0f, 0x0b, 0x0f, 0x0e, + 0x0f, 0x0f, 0x0f, 0x0e, + 0x0f, 0x0f, 0x0f, 0x0f}; + +#include "XShade.H1" + +Pixmap XShade[XShadeMax]; +GC TileGC; +unsigned int INIT = 1; + +/* + * This routine has the function of returning the number of characters needed + * to store a bitmap. It first calculates the number of bits needed per line. + * Then it finds the closest multiple of 8 which is bigger than the number of + * bits. Once that is done, it multiplies this number by the number of bits + * high the bitmap is. + */ +int +char_bitmap(void) +{ + int bits_line; + int total_chars; + + for (bits_line = 8, total_chars = 1; bits_line < XShadeWidth; total_chars++) + bits_line += 8; + + total_chars = total_chars * XShadeWidth; + + return total_chars; +} + +int +XInitShades(Display *display, int screen) +{ + char *bits; + int count; + int chars_bitmap = char_bitmap(); + int bit; + + bits = (char *) malloc(chars_bitmap * sizeof(char)); + + for (count = 0; count < XShadeMax; count++) { + + /* Load in the next bitmap */ + + for (bit = 0; bit < chars_bitmap; bit++) + bits[bit] = XShadeBits[count * chars_bitmap + bit]; + + /* Create it and put it into the Pixmap array */ + + XShade[count] = XCreatePixmapFromBitmapData(display, + RootWindow(display, screen), + bits, + XShadeWidth, XShadeWidth, + BlackPixel(display, screen), + WhitePixel(display, screen), + DisplayPlanes(display, screen)); + } + TileGC = XCreateGC(display, RootWindow(display, screen), 0, NULL); + XSetFillStyle(display, TileGC, FillTiled); + XSetTile(display, TileGC, XShade[XShadeMax / 2]); + return XShadeMax; +} + + +int +XChangeShade(Display *display, int shade) +{ + if (shade >= XShadeMax || shade < 0) { + fprintf(stderr, "Shade %d, out of range\n",shade); + return (-1); + } + XSetTile(display, TileGC, XShade[shade]); + return (1); +} + +int +XQueryShades(unsigned int *shades) +{ + *shades = XShadeMax; + return 1; +} + + +void +XShadeRectangle(Display *display, Drawable drawable, int x,int y, + unsigned int width, unsigned int height) +{ + if (!INIT) { + fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillRectangle(display, drawable, TileGC, x, y, width, height); +} + + +void +XShadeRectangles(Display *display, Drawable drawable, + XRectangle *rectangles, int nrectangles) +{ + if (!INIT) { + fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillRectangles(display, drawable, TileGC, + rectangles, nrectangles); +} + + +void +XShadePolygon(Display *display, Drawable drawable, XPoint * points, + int npoints, int shape, int mode) +{ + if (!INIT) { + fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); + exit(-1); + } + + XFillPolygon(display, drawable, TileGC, + points, npoints, shape, mode); +} + +void +XShadeArc(Display *display, Drawable drawable, int x, int y, + unsigned int width, unsigned int height, int angle1, int angle2) +{ + if (!INIT) { + fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillArc(display, drawable, TileGC, x, y, width, + height, angle1, angle2); +} + + +void +XShadeArcs(Display *display, Drawable drawable, XArc *arcs, int narcs) +{ + if (!INIT) { + fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); + exit(-1); + } + XFillArcs(display, drawable, TileGC, arcs, narcs); +} + +#endif /* MSYSplatform */ + diff --git a/src/lib/XShade.c.pamphlet b/src/lib/XShade.c.pamphlet deleted file mode 100644 index 8435b2dd..00000000 --- a/src/lib/XShade.c.pamphlet +++ /dev/null @@ -1,236 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib XShade.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -#ifndef MSYSplatform - -#include -#if !defined(BSDplatform) -#include -#endif -#include - -#include -#include -#include -#include -#include -#include - -#define XShadeWidth 4 -#define XShadeMax 17 - -char XShadeBits[] = { - 0x00, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x00, 0x00, - 0x01, 0x00, 0x04, 0x00, - 0x05, 0x00, 0x04, 0x00, - 0x05, 0x00, 0x05, 0x00, - 0x05, 0x02, 0x05, 0x00, - 0x05, 0x02, 0x05, 0x08, - 0x05, 0x0a, 0x05, 0x08, - 0x05, 0x0a, 0x05, 0x0a, - 0x07, 0x0a, 0x05, 0x0a, - 0x07, 0x0a, 0x0d, 0x0a, - 0x0f, 0x0a, 0x0d, 0x0a, - 0x0f, 0x0a, 0x0f, 0x0a, - 0x0f, 0x0b, 0x0f, 0x0a, - 0x0f, 0x0b, 0x0f, 0x0e, - 0x0f, 0x0f, 0x0f, 0x0e, - 0x0f, 0x0f, 0x0f, 0x0f}; - -#include "XShade.H1" - -Pixmap XShade[XShadeMax]; -GC TileGC; -unsigned int INIT = 1; - -/* - * This routine has the function of returning the number of characters needed - * to store a bitmap. It first calculates the number of bits needed per line. - * Then it finds the closest multiple of 8 which is bigger than the number of - * bits. Once that is done, it multiplies this number by the number of bits - * high the bitmap is. - */ -int -char_bitmap(void) -{ - int bits_line; - int total_chars; - - for (bits_line = 8, total_chars = 1; bits_line < XShadeWidth; total_chars++) - bits_line += 8; - - total_chars = total_chars * XShadeWidth; - - return total_chars; -} - -int -XInitShades(Display *display, int screen) -{ - char *bits; - int count; - int chars_bitmap = char_bitmap(); - int bit; - - bits = (char *) malloc(chars_bitmap * sizeof(char)); - - for (count = 0; count < XShadeMax; count++) { - - /* Load in the next bitmap */ - - for (bit = 0; bit < chars_bitmap; bit++) - bits[bit] = XShadeBits[count * chars_bitmap + bit]; - - /* Create it and put it into the Pixmap array */ - - XShade[count] = XCreatePixmapFromBitmapData(display, - RootWindow(display, screen), - bits, - XShadeWidth, XShadeWidth, - BlackPixel(display, screen), - WhitePixel(display, screen), - DisplayPlanes(display, screen)); - } - TileGC = XCreateGC(display, RootWindow(display, screen), 0, NULL); - XSetFillStyle(display, TileGC, FillTiled); - XSetTile(display, TileGC, XShade[XShadeMax / 2]); - return XShadeMax; -} - - -int -XChangeShade(Display *display, int shade) -{ - if (shade >= XShadeMax || shade < 0) { - fprintf(stderr, "Shade %d, out of range\n",shade); - return (-1); - } - XSetTile(display, TileGC, XShade[shade]); - return (1); -} - -int -XQueryShades(unsigned int *shades) -{ - *shades = XShadeMax; - return 1; -} - - -void -XShadeRectangle(Display *display, Drawable drawable, int x,int y, - unsigned int width, unsigned int height) -{ - if (!INIT) { - fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillRectangle(display, drawable, TileGC, x, y, width, height); -} - - -void -XShadeRectangles(Display *display, Drawable drawable, - XRectangle *rectangles, int nrectangles) -{ - if (!INIT) { - fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillRectangles(display, drawable, TileGC, - rectangles, nrectangles); -} - - -void -XShadePolygon(Display *display, Drawable drawable, XPoint * points, - int npoints, int shape, int mode) -{ - if (!INIT) { - fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); - exit(-1); - } - - XFillPolygon(display, drawable, TileGC, - points, npoints, shape, mode); -} - -void -XShadeArc(Display *display, Drawable drawable, int x, int y, - unsigned int width, unsigned int height, int angle1, int angle2) -{ - if (!INIT) { - fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillArc(display, drawable, TileGC, x, y, width, - height, angle1, angle2); -} - - -void -XShadeArcs(Display *display, Drawable drawable, XArc *arcs, int narcs) -{ - if (!INIT) { - fprintf(stderr, "XShade Error: Tried to fill before INIT called\n"); - exit(-1); - } - XFillArcs(display, drawable, TileGC, arcs, narcs); -} - -#endif /* MSYSplatform */ - -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/XSpadFill.c b/src/lib/XSpadFill.c new file mode 100644 index 00000000..71e6f16b --- /dev/null +++ b/src/lib/XSpadFill.c @@ -0,0 +1,300 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* + This file contains the routines needed in order to dither using the + spadcolors. The routines will have names such as XSpadFill, ... The user + simply gives the normal arguments as with the corresponding XFill routine, + with two additional arguments which choose the shade and the hue. + + The file will maintain twoGC's: stippleGC - will be used when stippling the + backgrounds. solidGC - will be used when the background should be solid + + The user should call XSpadInit to get everthing going. This routine has the + job of Initializing the dithering routines, and getting the colors all + into place. + + */ + + +#include "axiom-c-macros.h" +#ifndef MSYSplatform + +#include +#include + +#include +#include +#include +#include +#include + +#include "spadcolors.h" + +#include "XSpadFill.H1" +#include "XShade.H1" +#include "XDither.H1" +#include "spadcolors.H1" + +extern unsigned long *spadColors; +static GC stippleGC, solidGC; +Colormap cmap; +int SpadFillInit = 0; +long white, black; +int max_spad_shades; +extern Display *dsply; + +extern int totalHues; +extern int totalDithered; +extern int totalSolid; +extern int totalShades; +extern int totalColors; +extern int maxGreyShade; + +int +XInitSpadFill(Display *dsply, int scr, Colormap * mapOfColors, int * hues, + int *solid, int * dithered, int * shades) +{ + int maxDither; + XColor BlackColor, WhiteColor; + XColor retColor; + int maxSolid; + + SpadFillInit = 1; + + + /* + * First thing I should do is get the GC's + */ + stippleGC = XCreateGC(dsply, RootWindow(dsply, scr), 0, NULL); + solidGC = XCreateGC(dsply, RootWindow(dsply, scr), 0, NULL); + XSetArcMode(dsply, solidGC, ArcPieSlice); + XSetArcMode(dsply, stippleGC, ArcPieSlice); + + + cmap = DefaultColormap(dsply, scr); + *mapOfColors = cmap; + XAllocNamedColor(dsply, cmap, "Black", &BlackColor, &retColor); + XAllocNamedColor(dsply, cmap, "White", &WhiteColor, &retColor); + black = BlackColor.pixel; + white = WhiteColor.pixel; + + /* + * Now I check to see if I am on a monochrome display. If so then I + * simply set totalHues to be one, and total Shades to be 2. I also have + * to allocate balck and white colors. This I put into the first two + * memory locations of spadcolors. + * + * was if(DisplayPlanes(dsply, scr) < 2) changed temporarily to < 8 + * because of problems with screens with 4 planes . Now if we don't have + * 8 planes to play with we switch to monochrome + */ + + if (DisplayPlanes(dsply, scr) < 8) { + *dithered = totalDithered = maxGreyShade = XInitShades(dsply, scr); + maxDither = *dithered - 1; + spadColors = (unsigned long *) malloc(2 * sizeof(unsigned long)); + spadColors[0] = BlackColor.pixel; + spadColors[1] = WhiteColor.pixel; + *hues = totalHues = 1; + *solid = totalSolid = 2; + *shades = totalColors = totalShades = totalDithered; + return (totalColors); + } + + /* + * Now I have to get all the spad colors as every good spad program + * should Now I should initialize the dithering routines + */ + + *dithered = totalDithered = + XInitDither(dsply, scr, stippleGC, black, white); + maxDither = *dithered - 1; + + if ((maxSolid = makeColors(dsply, scr, &cmap, &spadColors, &totalSolid)) > 0) { + *solid = totalSolid + 2; + *hues = totalHues = maxSolid / totalSolid; + *shades = totalShades = (totalSolid + 1) * (totalDithered - 1) + 1; + totalColors = totalHues * totalShades; + return (totalColors); + } + else { + + /* + * makeColors managed to fail -- switch to mono + */ + *dithered = totalDithered = maxGreyShade = XInitShades(dsply, scr); + maxDither = *dithered - 1; + spadColors = (unsigned long *) malloc(2 * sizeof(unsigned long)); + spadColors[0] = BlackColor.pixel; + spadColors[1] = WhiteColor.pixel; + *hues = totalHues = 1; + *solid = totalSolid = 2; + *shades = totalColors = totalShades = totalDithered; + return (totalColors); + } +} + + +void +XSpadFillSetArcMode(Display *dsply, int mode) +{ + XSetArcMode(dsply, solidGC, mode); + XSetArcMode(dsply, stippleGC, mode); +} + +GC +SpadFillGC(Display *dsply,int hue, int theshade,char * fill_routine) +{ + int dither; + int color; + + + if (!SpadFillInit) { + fprintf(stderr, "Tried to use SpadFillGC before calling XInitSpadFill\n"); + exit(0); + } + + if (theshade >= totalShades) { + fprintf(stderr, "Shade %d out of range\n",theshade); + exit(-1); + } + if (hue >= totalHues) { + fprintf(stderr, "Error Hue %d is out of range\n",hue); + exit(-1); + } + dither = ((theshade) % (totalDithered - 1)); + if (dither != 0) { + XChangeDither(dsply, stippleGC, dither); + if (theshade < totalDithered) { /* Dither to black */ + color = totalSolid * hue; + XSetForeground(dsply, stippleGC, black); + XSetBackground(dsply, stippleGC, spadColors[color]); + } + else if (theshade > (totalShades - totalDithered)) { /* Dither to white */ + color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1; + XSetForeground(dsply, stippleGC, spadColors[color]); + XSetBackground(dsply, stippleGC, white); + } + else { + color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1; + XSetForeground(dsply, stippleGC, spadColors[color]); + XSetBackground(dsply, stippleGC, spadColors[color + 1]); + } + return (stippleGC); + } + else { + if (theshade == 0) + XSetForeground(dsply, solidGC, black); + else if (theshade == (totalShades - 1)) + XSetForeground(dsply, solidGC, white); + else { + color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1; + XSetForeground(dsply, solidGC, spadColors[color]); + } + return (solidGC); + } + +} + +unsigned long +XSolidColor(int hue, int theshade) +{ + if (hue >= totalHues) + return -1; + if (theshade >= totalSolid) + return -1; + return (spadColors[hue * (totalSolid) + theshade]); +} + +void +XSpadFillRectangle(Display *dsply, Drawable drawable, int x, int y, + unsigned int width, unsigned int height, + int hue, int theshade) +{ + + XFillRectangle(dsply, drawable, + SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), + x, y, width, height); + +} + + +void +XSpadFillRectangles(Display *dsply, Drawable drawable, + XRectangle * rectangles, int nrectangles, + int hue, int theshade) +{ + + + XFillRectangles(dsply, drawable, + SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), + rectangles, nrectangles); + +} + + +void +XSpadFillPolygon(Display *dsply, Drawable drawable, XPoint * points, + int npoints, int shape, int mode, int hue, int theshade) +{ + XFillPolygon(dsply, drawable, + SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), + points, npoints, shape, mode); + +} + +void +XSpadFillArc(Display *dsply, Drawable drawable, int x, int y, + unsigned int width, unsigned int height, + int angle1, int angle2, int hue, int theshade) +{ + + XFillArc(dsply, drawable, + SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), + x, y, width, height, angle1, angle2); +} + + +void +XSpadFillArcs(Display *dsply, Drawable drawable,XArc *arcs, int narcs, + int hue, int theshade) +{ + XFillArcs(dsply, drawable, + SpadFillGC(dsply, hue, theshade, "XSpadFillArcs"), + arcs, narcs); +} + + +#endif /* MSYSplatform */ + diff --git a/src/lib/XSpadFill.c.pamphlet b/src/lib/XSpadFill.c.pamphlet deleted file mode 100644 index 0172ea32..00000000 --- a/src/lib/XSpadFill.c.pamphlet +++ /dev/null @@ -1,321 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib XSpadFill.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\begin{verbatim} - -This file contains the routines needed in order to dither using the -spadcolors. The routines will have names such as XSpadFill, ... The user -simply gives the normal arguments as with the corresponding XFill routine, -with two additional arguments which choose the shade and the hue. - -The file will maintain twoGC's: stippleGC - will be used when stippling the -backgrounds. solidGC - will be used when the background should be solid - -The user should call XSpadInit to get everthing going. This routine has the -job of Initializing the dithering routines, and getting the colors all -into place. - -\end{verbatim} -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -#ifndef MSYSplatform - -#include -#include - -#include -#include -#include -#include -#include - -#include "spadcolors.h" - -#include "XSpadFill.H1" -#include "XShade.H1" -#include "XDither.H1" -#include "spadcolors.H1" - -extern unsigned long *spadColors; -static GC stippleGC, solidGC; -Colormap cmap; -int SpadFillInit = 0; -long white, black; -int max_spad_shades; -extern Display *dsply; - -extern int totalHues; -extern int totalDithered; -extern int totalSolid; -extern int totalShades; -extern int totalColors; -extern int maxGreyShade; - -int -XInitSpadFill(Display *dsply, int scr, Colormap * mapOfColors, int * hues, - int *solid, int * dithered, int * shades) -{ - int maxDither; - XColor BlackColor, WhiteColor; - XColor retColor; - int maxSolid; - - SpadFillInit = 1; - - - /* - * First thing I should do is get the GC's - */ - stippleGC = XCreateGC(dsply, RootWindow(dsply, scr), 0, NULL); - solidGC = XCreateGC(dsply, RootWindow(dsply, scr), 0, NULL); - XSetArcMode(dsply, solidGC, ArcPieSlice); - XSetArcMode(dsply, stippleGC, ArcPieSlice); - - - cmap = DefaultColormap(dsply, scr); - *mapOfColors = cmap; - XAllocNamedColor(dsply, cmap, "Black", &BlackColor, &retColor); - XAllocNamedColor(dsply, cmap, "White", &WhiteColor, &retColor); - black = BlackColor.pixel; - white = WhiteColor.pixel; - - /* - * Now I check to see if I am on a monochrome display. If so then I - * simply set totalHues to be one, and total Shades to be 2. I also have - * to allocate balck and white colors. This I put into the first two - * memory locations of spadcolors. - * - * was if(DisplayPlanes(dsply, scr) < 2) changed temporarily to < 8 - * because of problems with screens with 4 planes . Now if we don't have - * 8 planes to play with we switch to monochrome - */ - - if (DisplayPlanes(dsply, scr) < 8) { - *dithered = totalDithered = maxGreyShade = XInitShades(dsply, scr); - maxDither = *dithered - 1; - spadColors = (unsigned long *) malloc(2 * sizeof(unsigned long)); - spadColors[0] = BlackColor.pixel; - spadColors[1] = WhiteColor.pixel; - *hues = totalHues = 1; - *solid = totalSolid = 2; - *shades = totalColors = totalShades = totalDithered; - return (totalColors); - } - - /* - * Now I have to get all the spad colors as every good spad program - * should Now I should initialize the dithering routines - */ - - *dithered = totalDithered = - XInitDither(dsply, scr, stippleGC, black, white); - maxDither = *dithered - 1; - - if ((maxSolid = makeColors(dsply, scr, &cmap, &spadColors, &totalSolid)) > 0) { - *solid = totalSolid + 2; - *hues = totalHues = maxSolid / totalSolid; - *shades = totalShades = (totalSolid + 1) * (totalDithered - 1) + 1; - totalColors = totalHues * totalShades; - return (totalColors); - } - else { - - /* - * makeColors managed to fail -- switch to mono - */ - *dithered = totalDithered = maxGreyShade = XInitShades(dsply, scr); - maxDither = *dithered - 1; - spadColors = (unsigned long *) malloc(2 * sizeof(unsigned long)); - spadColors[0] = BlackColor.pixel; - spadColors[1] = WhiteColor.pixel; - *hues = totalHues = 1; - *solid = totalSolid = 2; - *shades = totalColors = totalShades = totalDithered; - return (totalColors); - } -} - - -void -XSpadFillSetArcMode(Display *dsply, int mode) -{ - XSetArcMode(dsply, solidGC, mode); - XSetArcMode(dsply, stippleGC, mode); -} - -GC -SpadFillGC(Display *dsply,int hue, int theshade,char * fill_routine) -{ - int dither; - int color; - - - if (!SpadFillInit) { - fprintf(stderr, "Tried to use SpadFillGC before calling XInitSpadFill\n"); - exit(0); - } - - if (theshade >= totalShades) { - fprintf(stderr, "Shade %d out of range\n",theshade); - exit(-1); - } - if (hue >= totalHues) { - fprintf(stderr, "Error Hue %d is out of range\n",hue); - exit(-1); - } - dither = ((theshade) % (totalDithered - 1)); - if (dither != 0) { - XChangeDither(dsply, stippleGC, dither); - if (theshade < totalDithered) { /* Dither to black */ - color = totalSolid * hue; - XSetForeground(dsply, stippleGC, black); - XSetBackground(dsply, stippleGC, spadColors[color]); - } - else if (theshade > (totalShades - totalDithered)) { /* Dither to white */ - color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1; - XSetForeground(dsply, stippleGC, spadColors[color]); - XSetBackground(dsply, stippleGC, white); - } - else { - color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1; - XSetForeground(dsply, stippleGC, spadColors[color]); - XSetBackground(dsply, stippleGC, spadColors[color + 1]); - } - return (stippleGC); - } - else { - if (theshade == 0) - XSetForeground(dsply, solidGC, black); - else if (theshade == (totalShades - 1)) - XSetForeground(dsply, solidGC, white); - else { - color = ((theshade) / (totalDithered - 1)) + totalSolid * hue - 1; - XSetForeground(dsply, solidGC, spadColors[color]); - } - return (solidGC); - } - -} - -unsigned long -XSolidColor(int hue, int theshade) -{ - if (hue >= totalHues) - return -1; - if (theshade >= totalSolid) - return -1; - return (spadColors[hue * (totalSolid) + theshade]); -} - -void -XSpadFillRectangle(Display *dsply, Drawable drawable, int x, int y, - unsigned int width, unsigned int height, - int hue, int theshade) -{ - - XFillRectangle(dsply, drawable, - SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), - x, y, width, height); - -} - - -void -XSpadFillRectangles(Display *dsply, Drawable drawable, - XRectangle * rectangles, int nrectangles, - int hue, int theshade) -{ - - - XFillRectangles(dsply, drawable, - SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), - rectangles, nrectangles); - -} - - -void -XSpadFillPolygon(Display *dsply, Drawable drawable, XPoint * points, - int npoints, int shape, int mode, int hue, int theshade) -{ - XFillPolygon(dsply, drawable, - SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), - points, npoints, shape, mode); - -} - -void -XSpadFillArc(Display *dsply, Drawable drawable, int x, int y, - unsigned int width, unsigned int height, - int angle1, int angle2, int hue, int theshade) -{ - - XFillArc(dsply, drawable, - SpadFillGC(dsply, hue, theshade, "XSpadFillRectangle"), - x, y, width, height, angle1, angle2); -} - - -void -XSpadFillArcs(Display *dsply, Drawable drawable,XArc *arcs, int narcs, - int hue, int theshade) -{ - XFillArcs(dsply, drawable, - SpadFillGC(dsply, hue, theshade, "XSpadFillArcs"), - arcs, narcs); -} - - -#endif /* MSYSplatform */ - -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/bsdsignal.c b/src/lib/bsdsignal.c new file mode 100644 index 00000000..3454507f --- /dev/null +++ b/src/lib/bsdsignal.c @@ -0,0 +1,71 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" +#include "bsdsignal.h" + +#if defined(MACOSXplatform) +#include "/usr/include/signal.h" +#else +#include +#endif + +#include "bsdsignal.H1" + + +SignalHandlerFunc +bsdSignal(int sig, SignalHandlerFunc action, int restartSystemCall) +{ +#if HAVE_DECL_SIGACTION + + struct sigaction in,out; + in.sa_handler = action; + /* handler is reinstalled - calls are restarted if restartSystemCall */ +#ifdef SA_RESTART + if(restartSystemCall) in.sa_flags = SA_RESTART; + else in.sa_flags = 0; +#elif defined(SA_INTERRUPT) + if (restartSystemCall) in.sa_flags = 0; + else in.sa_flags = SA_INTERRUPT; +#else + in.sa_flags = 0; +#endif + + return (sigaction(sig, &in, &out) ? (SignalHandlerFunc) -1 : + (SignalHandlerFunc) out.sa_handler); +#else /* !HAVE_DECL_SIGACTION */ + return (SignalHandlerFunc) -1; +#endif /* HAVE_DECL_SIGACTION */ +} + + diff --git a/src/lib/bsdsignal.c.pamphlet b/src/lib/bsdsignal.c.pamphlet deleted file mode 100644 index 5807659b..00000000 --- a/src/lib/bsdsignal.c.pamphlet +++ /dev/null @@ -1,320 +0,0 @@ -\documentclass{article} -\usepackage{axiom} - -\newcommand{\var}[1]{\textsl{#1}} - -\title{\File{src/lib/bsdsignal.c} Pamphlet} -\author{The Axiom Team} - -\begin{document} -\maketitle - -\begin{abstract} -\end{abstract} -\eject - -\tableofcontents -\newpage - -\section{Executive Overview} - -\section{Signals} - -The system defines a set of signals that may be delivered to a process. -Signal -delivery resembles the occurrence of a hardware interrupt: the signal is -normally blocked from further occurrence, the current process context is -saved, -and a new one is built. A process may specify a \emph{handler} to -which a signal -is delivered, or specify that a signal is to be \emph{ignored}. A process may -also specify that a default action is to be taken by the system when a signal -occurs. A signal may also be \emph{blocked}, in which case its delivery is -postponed until it is \emph{unblocked}. The action to be taken on delivery is -determined at the time of delivery. Normally, signal handlers execute on the -current stack of the process. This may be changed, on a per-handler basis, so -that signals are taken on a special \emph{signal stack}. - -Signal routines normally execute with the signal that caused their invocation -\emph{blocked}, but other signals may yet occur. A global \emph{signal mask} -defines the set of signals currently blocked from delivery to a process. -The signal mask for a process is initialized from that of its parent -(normally empty). It may be changed with a \emph{[[sigprocmask]](2)} call, or -when a signal is delivered to the process. - -When a signal condition arises for a process, the signal is added to a set of -signals pending for the process. If the signal is not currently \emph{blocked} -by the process then it is delivered to the process. Signals may be delivered -any time a process enters the operating system (e.g., during a system call, -page fault or trap, or clock interrupt). If muliple signals are ready to be -delivered at the same time, any signals that could be caused by traps are -delivered first. Additional signals may be processed at the same time, with -each appearing to interrupt the handlers for the previous signals before -their first instructions. The set of pending signals is retuned by the -\emph{[[sigpending]](2)} system call. When a caught signal is delivered, -the current -state of the process is saved, a new signal mask is calculated (as described -below), and the signal handler is invoked. The call to the handler is arranged -so that if the signal handling routine returns normally the process will resume -execution in the context from before the signal's delivery. If the process -wishes to resume in a different context, then it must arrange to restore -the previous context itself. - -When a signal is delivered to a proces a new signal mask is installed for the -duration of the process's signal handler (or until a \emph{[[sigprocmask]](2)} -system call is made). This mask is formed by taking the union of the current -signal mask set, the signal to be delivered, and the signal mask associated -with the handler to be invoked. - -The \emph{[[sigaction]]()} system call assigns an action for a signal -specified by \var{sig}. If \var{act} is non-zero, it specifies an action -([[SIG_DFL]], [[SIG_IGN]], or a handler routine) and mask to be used when -delivering the specified signal. -If \var{oact} is non-zero, the previous handling information for the signal is -returned to the user. - -Once a signal handler is installed, it normally remains installed until -another -[[sigaction()]] system call is made, or an \emph{[[execve]](2)} is performed. -A -signal-specific default action may be reset by setting [[sa_handler]] to -[[SIG_DFL]]. The defaults are process termination, possibly with core dump; -no action; stopping the process; or continuing the process. See the signal -list below for each signal's default action. If [[sa_handler]] is [[SIG_DFL]], -the default action for the signal is to discard the signal, and if a signal -is pending, the pending signal is discarded even if the signal is masked. If -[[sa_handler]] is set to [[SIG_IGN]] current and pending instances of the -signal -are ignored and discarded. - -Options may be specified by setting [[sa_flags]]. The meaning of the various -bits is as follows: -\begin{tabular}{ll} -SA\_NOCLDSTOP & If this bit is set when installing a catching function for\\ - & the SIGCHLD signal, the SIGCHLD signal will be generated only\\ - & when a child process exits, not when a child process stops.\\ -SA\_NOCLDWAIT & If this bit is set when calling {\sl sigaction()} for the\\ - & SIGCHLD signal, the system will not create zombie processes\\ - & when children of the calling process exit. If the calling\\ - & process subsequently issues a {\sf wait()} (or equivalent),\\ - & it blocks until all of the calling process's child processes\\ - & terminate, and then returns a value of -1 with errno set to\\ - & ECHILD.\\ -SA\_ONSTACK & If this bit is set, the system will deliver the signal to\\ - & the process on a {\sl signal stack}, specified with\\ - & {\bf sigaltstack(2)}.\\ -SA\_NODEFER & If this bit is set, further occurrences of the delivered\\ - & signal are not masked during the execution of the handler.\\ -SA\_RESETHAND & If this bit is set, the handler is reset back to SIG\_DFL\\ - & at the moment the signal is delivered.\\ -SA\_RESTART & See the paragraph below\\ -SA\_SIGINFO & If this bit is set, the handler function is assumed to be\\ - & pointed to by the sa\_sigaction member of struct sigaction\\ - & and should match the prototype shown above or as below in\\ - & EXAMPLES. This bit should not be set when assigning SIG\_DFL\\ - & or SIG\_IGN -\end{tabular} - -If a signal is caught during the system calls listed below, the call may be -forced to terminate with the error [[EINTR]], the call may return with a data -transfer shorter than requested, or the call may be restarted. Restart of -pending calls is requested by setting the SA\_RESTART bit in {\sl sa\_flags}. -The affected system calls include {\bf open(2)}, {\bf read(2)}, {\bf write(2)}, -{\bf sendto(2)}, {\bf recvfrom(2)}, {\bf sendmsg(2)} and {\bf recvmsg(2)} -on a communications channel or a slow device (such as a terminal, but not a -regular file) and during a {\bf wait(2)} or {\bf ioctl(2)}. However, calls -that have already committed are not restarted, but instead return a partial -success (for example, a short read count). - -After a {\bf fork(2)} or {\bf vfork(2)} all signals, the signal mask, the -signal stack, and the restart/interrupt flags are inherited by the child. - -The {\bf execve(2)} system call reinstates the default action for all signals -which were caught and resets all signals to be caught on the user stack. -Ignored signals remain ignored; the signal mask remains the same; signals -that restart pending system calls continue to do so. - -The following is a list of all signals with names as in the include file -{\sl }: - -\begin{tabular}{lll} -{\bf NAME} & {\bf Default Action} & Description\\ -SIGHUP & terminate process & terminal line hangup\\ -SIGINT & terminate process & interrupt program\\ -SIGQUIT & create core image & quit program\\ -SIGILL & create core image & illegal instruction\\ -SIGTRAP & create core image & trace trap\\ -SIGABRT & create core image & {\bf abort(3)} call (formerly SIGIOT)\\ -SIGEMT & create core image & emulate instruction executed\\ -SIGFPE & create core image & floating-point exception\\ -SIGKILL & terminate process & kill program\\ -SIGBUS & create core image & bus error\\ -SIGSEGV & create core image & segmentation violation\\ -SIGSYS & create core image & non-existent system call invoked\\ -SIGPIPE & terminate process & write on a pipe with no reader\\ -SIGALRM & terminate process & real-time timer expired\\ -SIGTERM & terminate process & software termination signal\\ -SIGURG & discard signal & urgent condition present on socket\\ -SIGSTOP & stop process & stop (cannot be caught or ignored)\\ -SIGSTP & stop process & stop signal generated from keyboard\\ -SIGCONT & discard signal & continue after stop\\ -SIGCHLD & discard signal & child status has changed\\ -SIGTTIN & stop process & background read attempted from \\ - & & control terminal\\ -SIGTTOU & stop process & background write attempted from\\ - & & control terminal\\ -SIGIO & discard signal & I/O is possible on a descriptor {\bf fcntl(2)}\\ -SIGXCPU & terminate process & cpu time limit exceeded {\bf setrlimit(2)}\\ -SIGXFSZ & terminate process & file size limit exceeded {\bf setrlimit(2)}\\ -SIGVTALRM & terminate process & virtual time alarm {\bf setitimer(2)}\\ -SIGPROF & terminate process & profiling timer alarm {\bf setitimer(2)}\\ -SIGWINCH & discard signal & Window size change\\ -SIGINFO & discard signal & status request from keyboard\\ -SIGUSR1 & terminate process & User defined signal 1\\ -SIGUSR2 & terminate process & User defined signal 2 -\end{tabular} - -The {\sl sigaction()} function returns the value 0 if successful; otherwise -the value -1 is returned and the global variable {\sl errno} is set to indicate -the error. - -Signal handlers should have either the ANSI C prototype: -\begin{verbatim} - void handler(int); -\end{verbatim} -or the POSIX SA\_SIGINFO prototype: -\begin{verbatim} - void handler(int, siginfo\_t *info, ucontext\_t *uap); -\end{verbatim} - -The handler function should match the SA\_SIGINFO prototype if the SA\_SIGINFO -bit is set in flags. It then should be pointed to by the sa\_sigaction member -of struct sigaction. Note that you should not assign SIG\_DFL or SIG\_IGN this way. - -If the SA\_SIGINFO flag is not set, the handler function should match either -the ANSI C or traditional BSD prototype and be pointed to by the sa\_handler -member of struct sigaction. In practice, FreeBSD always sends the three -arguments of the latter and since the ANSI C prototype is a subset, both -will work. The sa\_handler member declaration in FreeBSD include files is -that of ANSI C (as required by POSIX), so a function pointer of a BSD-style -function needs to be casted to compile without warning. The traditional BSD -style is not portable and since its capabilities are a full subset of a -SA\_SIGNFO handler its use is deprecated. - -The {\sl sig} argument is the signal number, one of the SIG\ldots values from -{\sl }. - -The {\sl code} argument of the BSD-style handler and the si\_code member of the -info argument to a SA\_SIGINFO handler contain a numeric code explaining the -cause of the signal, usually on of the SI\_\ldots values from {\sl } -or codes specific to a signal, i.e. one of the FPE\_\ldots values for SIGFPE. - -The {\sl uap} argument to a POSIX SA\_SIGINFO handler points to an instance of -ucontext\_t. - -The {\bf sigaction()} system call will fail and no new signal handler will be -installed if one of the following occurs: -\begin{tabular}{ll} -EFAULT & Either {\sl act} or {\sl oact} points to memory that is not a\\ - & valid part of the process address space\\ -EINVAL & The {\sl sig} argument is not a valid signal number\\ -EINVAL & An attempt is made to ignore or supply a handler for SIGKILL\\ - & or SIGSTOP -\end{tabular} -\section{MAC OSX and BSD platform change} -<<*>>= -<> - -#include "axiom-c-macros.h" -#include "bsdsignal.h" - -@ -The MACOSX platform is broken because no matter what you do it seems to -include files from [[/usr/include/sys]] ahead of [[/usr/include]]. On linux -systems these files include themselves which causes an infinite regression -of includes that fails. GCC gracefully steps over that problem but the -build fails anyway. On MACOSX the [[/usr/include/sys]] versions -of files are badly broken with respect to the [[/usr/include]] versions. -<<*>>= -#if defined(MACOSXplatform) -#include "/usr/include/signal.h" -#else -#include -#endif - -#include "bsdsignal.H1" - - -SignalHandlerFunc -bsdSignal(int sig, SignalHandlerFunc action, int restartSystemCall) -{ -#if HAVE_DECL_SIGACTION - - struct sigaction in,out; - in.sa_handler = action; - /* handler is reinstalled - calls are restarted if restartSystemCall */ -@ - -We needed to change [[SIGCLD]] to [[SIGCHLD]] for the [[MAC OSX]] platform -and we need to create a new platform variable. This change is made to -propogate that platform variable. -<<*>>= -#ifdef SA_RESTART - if(restartSystemCall) in.sa_flags = SA_RESTART; - else in.sa_flags = 0; -#elif defined(SA_INTERRUPT) - if (restartSystemCall) in.sa_flags = 0; - else in.sa_flags = SA_INTERRUPT; -#else - in.sa_flags = 0; -#endif - - return (sigaction(sig, &in, &out) ? (SignalHandlerFunc) -1 : - (SignalHandlerFunc) out.sa_handler); -#else /* !HAVE_DECL_SIGACTION */ - return (SignalHandlerFunc) -1; -#endif /* HAVE_DECL_SIGACTION */ -} - - -@ -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -\newpage -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/cfuns-c.c b/src/lib/cfuns-c.c new file mode 100644 index 00000000..de00deee --- /dev/null +++ b/src/lib/cfuns-c.c @@ -0,0 +1,265 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Copyright (C) 2007, Gabriel Dos Reis +*/ + +#include +#include +#include +#include +#include +#include +#include "axiom-c-macros.h" + +#include "cfuns-c.H1" + +/* Most versions of Windows don't have the POSIX functions getuid(), + geteuid(), getgid(), and getegid(). The following definitions are + approximations, to patch for the deficiencies of Windows + POSIX interface. */ + +#if !HAVE_DECL_GETUID +# define getuid() 0 +#endif + +#if !HAVE_DECL_GETGID +# define getgid() 0 +#endif + +#if !HAVE_DECL_GETEUID +# define geteuid() getuid() +#endif + +#if !HAVE_DECL_GETEGID +# define getegid() getgid() +#endif + +int +addtopath(char *dir) +{ + char *path, *newpath; + + path = getenv("PATH"); + if (path == NULL) + return -1; + + newpath = (char *) malloc(1 + strlen(path) + strlen(dir) + strlen("PATH=:")); + if (newpath == NULL) + return -1; + + sprintf(newpath, "PATH=%s:%s", path, dir); + + return putenv(newpath); +} + +/* + * Test whether the path is the name of a directory. Returns 1 if so, 0 if + * not, -1 if it doesn't exist. + */ + + +int +directoryp(char *path) +{ + struct stat buf; + int code = stat(path, &buf); + + return code == -1 ? -1 : S_ISDIR(buf.st_mode); +} + +int +make_path_from_file(char *s, char *t) +{ + char *pos = ""; + char *c; + + /** simply copies the path name from t into s **/ + for (c = t + strlen(t); c != s; c--) + if (*c == '/') { + pos = c; + break; + } + /** Check to see if the path was actually present **/ + if (c == t) { /** No Path, so return the pwd **/ + return (-1); + } + /** now just do the copying **/ + strncpy(s, t, pos - t); + return 1; +} + +/* The functions writeablep() and readablep() determine write and + read access of a file designated by its name. The function + axiom_has_write_access is a sub-routine of writeablep. + + The access is determined based on the POSIX semantics; see + "Advanced Programming in the UNIX Environement", section 4.5. + + 1. If the effective user ID of the process is 0 (the superuser), + access is allowed. This gives the superuser free rein throughout + the entire file system. + + 2. If the effective user ID of the process equals the owner ID of + the file (i.e., the process owns the file), access is allowed + if the appropriate user access permission bit is set. [...] + + 3. If the effective group ID of the process or one of the + supplementary group IDs of the process equals the group ID + of the file, access is allowed if the appropriate + group access permission bit is set. Otherwise, permission + is denied. + + 4. If the appropriate other access permission bit is set, access is + allowed. Otherwise, permission is defined. */ + + +/* Return 1 if the process has write access of file as explained above. + Otherwise, return 0. */ + +static inline int +axiom_has_write_access(const struct stat* file_info) +{ + int effetive_uid = geteuid(); + + if (effetive_uid == 0) + return 1; + + if (effetive_uid == file_info->st_uid) + return file_info->st_mode & S_IWUSR; + +#ifdef S_IWGRP + if (getegid() == file_info->st_gid) + return file_info->st_mode & S_IWGRP; +#endif + +#ifdef S_IWOTH + return file_info->st_mode & S_IWOTH; +#else + return 0; +#endif +} + + +/* Return + -1 if the file designated by PATH is inexistent. + 0 if the file exists but wirte access is denied. + 1 if the file exists and process has write access. + 2 if the file does not exists but process has write + has write access to the dirname of path. */ + +int +writeablep(char *path) +{ + struct stat buf; + char newpath[100]; + int code; + + code = stat(path, &buf); + if (code == -1) { + /** The file does not exist, so check to see + if the directory is writable *****/ + if (make_path_from_file(newpath, path) == -1 + || stat(newpath, &buf) == -1) + return -1; + + return 2 * axiom_has_write_access(&buf); + } + + return axiom_has_write_access(&buf); +} + + +/* Return + -1 if the file designated by PATH is inexistent. + 0 if the file exists but process has no read access. + 1 if the file exists and read access is granted. */ + +int +readablep(char *path) +{ + struct stat buf; + int code; + + code = stat(path, &buf); + if (code == -1) + return -1; + + if (geteuid() == buf.st_uid) + return ((buf.st_mode & S_IREAD) != 0); + +#ifdef S_IRGRP + if (getegid() == buf.st_gid) + return ((buf.st_mode & S_IRGRP) != 0); +#endif + +#ifdef S_IROTH + return ((buf.st_mode & S_IROTH) != 0); +#else + return 0; +#endif +} + + + +long +findString(char *file, char *string) +{ + int nstring, charpos; + FILE *fn; + char buffer[1024]; + + if ((fn = fopen(file, "r")) == NULL) + return -1; + + for (charpos = 0, nstring = strlen(string); + fgets(buffer, sizeof buffer, fn) != NULL; + charpos += strlen(buffer) + ) + if (!strncmp(buffer, string, nstring)) + return charpos; + return -1; + +} + +int +copyEnvValue(char *varName, char *buffer) +{ + char *s; + + s = getenv(varName); + if (s == NULL) + return 0; + strcpy(buffer, s); + return strlen(s); +} + diff --git a/src/lib/cfuns-c.c.pamphlet b/src/lib/cfuns-c.c.pamphlet deleted file mode 100644 index ad5a97e8..00000000 --- a/src/lib/cfuns-c.c.pamphlet +++ /dev/null @@ -1,285 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib cfuns-c.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include -#include -#include -#include -#include -#include -#include "axiom-c-macros.h" - -#include "cfuns-c.H1" - -/* Most versions of Windows don't have the POSIX functions getuid(), - geteuid(), getgid(), and getegid(). The following definitions are - approximations, to patch for the deficiencies of Windows - POSIX interface. */ - -#if !HAVE_DECL_GETUID -# define getuid() 0 -#endif - -#if !HAVE_DECL_GETGID -# define getgid() 0 -#endif - -#if !HAVE_DECL_GETEUID -# define geteuid() getuid() -#endif - -#if !HAVE_DECL_GETEGID -# define getegid() getgid() -#endif - -int -addtopath(char *dir) -{ - char *path, *newpath; - - path = getenv("PATH"); - if (path == NULL) - return -1; - - newpath = (char *) malloc(1 + strlen(path) + strlen(dir) + strlen("PATH=:")); - if (newpath == NULL) - return -1; - - sprintf(newpath, "PATH=%s:%s", path, dir); - - return putenv(newpath); -} - -/* - * Test whether the path is the name of a directory. Returns 1 if so, 0 if - * not, -1 if it doesn't exist. - */ - - -int -directoryp(char *path) -{ - struct stat buf; - int code = stat(path, &buf); - - return code == -1 ? -1 : S_ISDIR(buf.st_mode); -} - -int -make_path_from_file(char *s, char *t) -{ - char *pos = ""; - char *c; - - /** simply copies the path name from t into s **/ - for (c = t + strlen(t); c != s; c--) - if (*c == '/') { - pos = c; - break; - } - /** Check to see if the path was actually present **/ - if (c == t) { /** No Path, so return the pwd **/ - return (-1); - } - /** now just do the copying **/ - strncpy(s, t, pos - t); - return 1; -} - -/* The functions writeablep() and readablep() determine write and - read access of a file designated by its name. The function - axiom_has_write_access is a sub-routine of writeablep. - - The access is determined based on the POSIX semantics; see - "Advanced Programming in the UNIX Environement", section 4.5. - - 1. If the effective user ID of the process is 0 (the superuser), - access is allowed. This gives the superuser free rein throughout - the entire file system. - - 2. If the effective user ID of the process equals the owner ID of - the file (i.e., the process owns the file), access is allowed - if the appropriate user access permission bit is set. [...] - - 3. If the effective group ID of the process or one of the - supplementary group IDs of the process equals the group ID - of the file, access is allowed if the appropriate - group access permission bit is set. Otherwise, permission - is denied. - - 4. If the appropriate other access permission bit is set, access is - allowed. Otherwise, permission is defined. */ - - -/* Return 1 if the process has write access of file as explained above. - Otherwise, return 0. */ - -static inline int -axiom_has_write_access(const struct stat* file_info) -{ - int effetive_uid = geteuid(); - - if (effetive_uid == 0) - return 1; - - if (effetive_uid == file_info->st_uid) - return file_info->st_mode & S_IWUSR; - -#ifdef S_IWGRP - if (getegid() == file_info->st_gid) - return file_info->st_mode & S_IWGRP; -#endif - -#ifdef S_IWOTH - return file_info->st_mode & S_IWOTH; -#else - return 0; -#endif -} - - -/* Return - -1 if the file designated by PATH is inexistent. - 0 if the file exists but wirte access is denied. - 1 if the file exists and process has write access. - 2 if the file does not exists but process has write - has write access to the dirname of path. */ - -int -writeablep(char *path) -{ - struct stat buf; - char newpath[100]; - int code; - - code = stat(path, &buf); - if (code == -1) { - /** The file does not exist, so check to see - if the directory is writable *****/ - if (make_path_from_file(newpath, path) == -1 - || stat(newpath, &buf) == -1) - return -1; - - return 2 * axiom_has_write_access(&buf); - } - - return axiom_has_write_access(&buf); -} - - -/* Return - -1 if the file designated by PATH is inexistent. - 0 if the file exists but process has no read access. - 1 if the file exists and read access is granted. */ - -int -readablep(char *path) -{ - struct stat buf; - int code; - - code = stat(path, &buf); - if (code == -1) - return -1; - - if (geteuid() == buf.st_uid) - return ((buf.st_mode & S_IREAD) != 0); - -#ifdef S_IRGRP - if (getegid() == buf.st_gid) - return ((buf.st_mode & S_IRGRP) != 0); -#endif - -#ifdef S_IROTH - return ((buf.st_mode & S_IROTH) != 0); -#else - return 0; -#endif -} - - - -long -findString(char *file, char *string) -{ - int nstring, charpos; - FILE *fn; - char buffer[1024]; - - if ((fn = fopen(file, "r")) == NULL) - return -1; - - for (charpos = 0, nstring = strlen(string); - fgets(buffer, sizeof buffer, fn) != NULL; - charpos += strlen(buffer) - ) - if (!strncmp(buffer, string, nstring)) - return charpos; - return -1; - -} - -int -copyEnvValue(char *varName, char *buffer) -{ - char *s; - - s = getenv(varName); - if (s == NULL) - return 0; - strcpy(buffer, s); - return strlen(s); -} - -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/cursor.c b/src/lib/cursor.c new file mode 100644 index 00000000..960d12e8 --- /dev/null +++ b/src/lib/cursor.c @@ -0,0 +1,142 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include +#include "axiom-c-macros.h" + +#include "cursor.H1" + +/* + * This routine changes the shape of the cursor. it is a modified version of + * a program by SMWatt, called cursor.c. JMW 6/22/89 + */ + +/* this stuff can only be done on AIX the right terminal (aixterm,hft) */ +#if (defined(RIOSplatform) || defined(RTplatform)) && !defined(_AIX41) +#include "edible.h" +/* the HFT stuff requires ioctl's and termio's */ +#include +#include +#include +#include + +int +Cursor_shape(int shape) +{ + int hftfd; + char hftpath[16], s[100]; + int chno; + int i; + struct termio oldterm, newterm; + struct hftgetid hftgid; + char *termVal; + + termVal = (char *) getenv("TERM"); + if (strcmp("hft", termVal) && strncmp("aixterm", termVal, 7)) + return; + + + + /* determine the desired shape */ + if (shape < 0 || shape > 5) { + fprintf(stderr, "%d - Invalid cursor number\n"); + return (-1); + } + /* change the shape */ + s[0] = 033; /* hf_intro.hf_esc */ + s[1] = '['; /* hf_intro.hf_lbr */ + s[2] = 'x'; /* hf_intro.hf_ex */ + s[3] = 0; /* hf_intro.hf_len[0] */ + s[4] = 0; /* hf_intro.hf_len[1] */ + s[5] = 0; /* hf_intro.hf_len[2] */ + s[6] = 10; /* hf_intro.hf_len[3] */ + s[7] = 2; /* hf_intro.hf_typehi */ + s[8] = 8; /* hf_intro.hf_typelo */ + s[9] = 2; /* hf_sublen */ + s[10] = 0; /* hf_subtype */ + s[11] = 0; /* hf_rsvd */ + s[12] = shape; /* hf_shape */ + + if (ioctl(0, HFTGETID, &hftgid) < 0) { + /* perror("ioctl: HFTGETID"); */ + chno = -1; + } + else + chno = hftgid.hf_chan; + if (chno == -1) { + /** try being moronic and just writing what I want to + standard output ****/ + + if (((ioctl(2, TCGETA, &oldterm)) == -1) || + ((ioctl(2, TCGETA, &newterm)) == -1)) { + perror("Getting termio"); + exit(0); + } + newterm.c_oflag = newterm.c_lflag = newterm.c_iflag = 0; + newterm.c_cc[0] = -1; + for (i = 1; i <= 5; i++) + newterm.c_cc[i] = 0; + if ((ioctl(2, TCSETAF, &newterm)) == -1) { + perror("Setting to raw mode"); + exit(0); + } + write(2, s, 13); + read(0, s, 1024); + if ((ioctl(2, TCSETAF, &oldterm)) == -1) { + perror("Resetting terminal"); + exit(0); + } + } + else { + /* open the currently active virtual terminal on the hft */ + sprintf(hftpath, "/dev/hft/%d", chno); + if ((hftfd = open(hftpath, O_RDWR)) == -1) { + perror("Could not open hft channel\n"); + exit(0); + } + write(hftfd, s, 13); + } +} +#else + +int +Cursor_shape(int shape) +{ + return shape; +} +#endif + + + + + diff --git a/src/lib/cursor.c.pamphlet b/src/lib/cursor.c.pamphlet deleted file mode 100644 index dd2d34da..00000000 --- a/src/lib/cursor.c.pamphlet +++ /dev/null @@ -1,164 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib cursor.c} -\author{Stephen Watt, James Wen} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include -#include "axiom-c-macros.h" - -#include "cursor.H1" - -/* - * This routine changes the shape of the cursor. it is a modified version of - * a program by SMWatt, called cursor.c. JMW 6/22/89 - */ - -/* this stuff can only be done on AIX the right terminal (aixterm,hft) */ -#if (defined(RIOSplatform) || defined(RTplatform)) && !defined(_AIX41) -#include "edible.h" -/* the HFT stuff requires ioctl's and termio's */ -#include -#include -#include -#include - -int -Cursor_shape(int shape) -{ - int hftfd; - char hftpath[16], s[100]; - int chno; - int i; - struct termio oldterm, newterm; - struct hftgetid hftgid; - char *termVal; - - termVal = (char *) getenv("TERM"); - if (strcmp("hft", termVal) && strncmp("aixterm", termVal, 7)) - return; - - - - /* determine the desired shape */ - if (shape < 0 || shape > 5) { - fprintf(stderr, "%d - Invalid cursor number\n"); - return (-1); - } - /* change the shape */ - s[0] = 033; /* hf_intro.hf_esc */ - s[1] = '['; /* hf_intro.hf_lbr */ - s[2] = 'x'; /* hf_intro.hf_ex */ - s[3] = 0; /* hf_intro.hf_len[0] */ - s[4] = 0; /* hf_intro.hf_len[1] */ - s[5] = 0; /* hf_intro.hf_len[2] */ - s[6] = 10; /* hf_intro.hf_len[3] */ - s[7] = 2; /* hf_intro.hf_typehi */ - s[8] = 8; /* hf_intro.hf_typelo */ - s[9] = 2; /* hf_sublen */ - s[10] = 0; /* hf_subtype */ - s[11] = 0; /* hf_rsvd */ - s[12] = shape; /* hf_shape */ - - if (ioctl(0, HFTGETID, &hftgid) < 0) { - /* perror("ioctl: HFTGETID"); */ - chno = -1; - } - else - chno = hftgid.hf_chan; - if (chno == -1) { - /** try being moronic and just writing what I want to - standard output ****/ - - if (((ioctl(2, TCGETA, &oldterm)) == -1) || - ((ioctl(2, TCGETA, &newterm)) == -1)) { - perror("Getting termio"); - exit(0); - } - newterm.c_oflag = newterm.c_lflag = newterm.c_iflag = 0; - newterm.c_cc[0] = -1; - for (i = 1; i <= 5; i++) - newterm.c_cc[i] = 0; - if ((ioctl(2, TCSETAF, &newterm)) == -1) { - perror("Setting to raw mode"); - exit(0); - } - write(2, s, 13); - read(0, s, 1024); - if ((ioctl(2, TCSETAF, &oldterm)) == -1) { - perror("Resetting terminal"); - exit(0); - } - } - else { - /* open the currently active virtual terminal on the hft */ - sprintf(hftpath, "/dev/hft/%d", chno); - if ((hftfd = open(hftpath, O_RDWR)) == -1) { - perror("Could not open hft channel\n"); - exit(0); - } - write(hftfd, s, 13); - } -} -#else - -int -Cursor_shape(int shape) -{ - return shape; -} -#endif - - - - - -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/edin.c b/src/lib/edin.c new file mode 100644 index 00000000..baa997ed --- /dev/null +++ b/src/lib/edin.c @@ -0,0 +1,941 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* #define debug 1 */ + +#include +#include "axiom-c-macros.h" +#if defined(MACOSXplatform) +#include "/usr/include/unistd.h" +#else +#include +#endif +#include +#include +#include + +#include "edible.h" + +#define HFT 0 +#define SUN 1 +#define DEC 2 +#define control_to_alpha(x) (x + ('A' - 0x01)) +#define alpha_to_control(x) (x - ('A' - 0x01)) + +int termId; +QueStruct *ring = NULL; +QueStruct *current = NULL; +int ring_size = 0; +int MAXRING = 64; +int prev_check = 10; +int curr_pntr; +int num_pntr; +int num_proc; +int had_tab; +int had_tab_last; +extern char buff[1024]; /* Buffers for collecting input and */ +extern int buff_flag[1024]; /* flags for whether buff chars + are printing or non-printing */ +int buff_pntr; /* present length of buff */ + + +#include "edin.H1" +#include "prt.H1" +#include "wct.H1" +#include "cursor.H1" +#include "fnct_key.H1" + + + +void +init_reader(void) +{ + char *termVal; + + buff[50] = '\0'; /** initialize some stuff ***/ + init_flag(buff_flag, MAXLINE); + buff_pntr = curr_pntr = 0; + + had_tab = 0; + had_tab_last = 0; + termVal = (char *) getenv("TERM"); + if (!strcmp("sun", termVal)) + termId = SUN; + else if (!strcmp("xterm", termVal) || !strncmp("vt", termVal, 2)) + termId = DEC; + else if (!strcmp("hft", termVal) || !strncmp("aixterm", termVal, 7)) + termId = HFT; +} + + +void +do_reading(void) +{ + int ttt_read; + int done_completely; + + done_completely = 0; + num_proc = 0; + while (num_proc < num_read) { + if(in_buff[num_proc]== _ERASE) { + back_over_current_char(); + num_proc++; + } + else { + switch (in_buff[num_proc]) { + /* lets start checking for different types of chars */ + case _EOLN: + case _CR: + /* If I have read a complete line, so send it to the child */ + send_line_to_child(); + if (!PTY) + myputchar('\n'); + break; + + /* + * Use 0x7f as delete + */ + case _DEL: + /* Had a delete key */ + delete_current_char(); + break; + + case _CNTRL_W: + move_back_word(); + num_proc++; + break; + case _TAB: + had_tab = 1; + /* command completion stuff */ + num_proc++; + if (had_tab_last) + rescan_wct(); + else + find_wct(); + break; + case _BELL: + insert_buff_nonprinting(1); + putchar(_BELL); + fflush(stdout); + break; + case _ESC: + + /* + * get 2 characters more + */ + while (!(num_read - num_proc > 2)) { + ttt_read = read(0, + in_buff + num_read, + 2 - (num_read - num_proc) + 1); + if (ttt_read > 0) + num_read = num_read + ttt_read; + } + if ((in_buff[num_proc + 1] == _LBRACK)) { + + /* ESC [ */ + + switch (in_buff[num_proc + 2]) { + /* look for arrows */ + case _A: + /* up arrow */ + + /* + * The first thing I plan to do is get rid of the present + * input ** + */ + prev_buff(); + curr_pntr = buff_pntr; + num_proc = num_proc + 3; + break; + case _B: + /* down arrow */ + next_buff(); + curr_pntr = buff_pntr; + num_proc = num_proc + 3; + break; + case _C: + /* right arrow */ + move_ahead(); + num_proc = num_proc + 3; + break; + case _D: + /* left arrow */ + move_back(); + num_proc = num_proc + 3; + break; + + /* + * Use ^[[P as delete + */ + case _P: + /*** Had a delete key ****/ + delete_current_char(); + break; + case _H: + case 0: + move_home(); + num_proc += 3; + break; + case _M: + case _Z: + insert_buff_nonprinting(3); + done_completely = 1; + num_proc += 3; + break; + case _x: + num_proc = num_read; + break; + case _1: + case _2: + case _0: + + /* + * I have had a possible function key hit, look for the + * ones I want. check for ESC ] x ~ + */ + while (!(num_read - num_proc > 3)) { + ttt_read = read(0, + in_buff + num_read, + 3 - (num_read - num_proc) + 1); + if (ttt_read > 0) + num_read = num_read + ttt_read; + } + if (in_buff[num_proc + 3] == _twiddle) { + + /* + * treat ESC ] x ~ + */ + switch (in_buff[num_proc + 2]) { + case _2: + flip(INS_MODE); + if (INS_MODE) + Cursor_shape(5); + else + Cursor_shape(2); + reprint(curr_pntr); + num_proc += 4; + break; + default: + insert_buff_nonprinting(1); + break; + } + break; + } + /* check for ESC ] x y ~ */ + while (!(num_read - num_proc > 4)) { + ttt_read = read(0, + in_buff + num_read, + 4 - (num_read - num_proc) + 1); + if (ttt_read > 0) + num_read = num_read + ttt_read; + } + if (in_buff[num_proc + 4] == _twiddle) { + + /* + * treat ESC ] x y ~ + */ + insert_buff_nonprinting(1); + break; + } + + /* check for ESC ] x y z [q|z] */ + + while (!(num_read - num_proc > 5)) { + ttt_read = read(0, + in_buff + num_read, + 5 - (num_read - num_proc) + 1); + if (ttt_read > 0) + num_read = num_read + ttt_read; + } + if (insert_toggle(&in_buff[num_proc + 3])) { + flip(INS_MODE); + if (INS_MODE) + Cursor_shape(5); + else + Cursor_shape(2); + reprint(curr_pntr); + num_proc = num_proc + 6; + break; + } + else if (cntrl_end(&in_buff[num_proc + 3])) { + num_proc = num_proc + 6; + delete_to_end_of_line(); + break; + } + else if (back_word(&in_buff[num_proc + 3])) { + move_back_word(); + num_proc += 6; + break; + } + else if (fore_word(&in_buff[num_proc + 3])) { + move_fore_word(); + num_proc += 6; + break; + } + else if (end_key(&in_buff[num_proc + 3])) { + move_end(); + num_proc += 6; + break; + } + switch (in_buff[num_proc + 5]) { + case _q: + + /* + * IBM function keys + */ + { + char num[3]; + int key; + + num[0] = in_buff[num_proc + 3]; + num[1] = in_buff[num_proc + 4]; + num[2] = '\0'; + key = atoi(num); + if (key > 0 && key < 13) { + if (function_key[key].str != NULL) { + handle_function_key(key, contNum); + done_completely = 1; + } + else { + insert_buff_nonprinting(6); + done_completely = 1; + } + } + else { + insert_buff_nonprinting(6); + done_completely = 1; + } + break; + } + case _z: + + /* + * Sun function keys + */ + { + char num[3]; + int key; + + num[0] = in_buff[num_proc + 3]; + num[1] = in_buff[num_proc + 4]; + num[2] = '\0'; + key = atoi(num) - 23; + if (key > 0 && key < 13) { + if (function_key[key].str != NULL) { + handle_function_key(key, contNum); + done_completely = 1; + } + else { + insert_buff_nonprinting(6); + done_completely = 1; + } + } + else if (atoi(num) == 14) { + move_home(); + num_proc += 6; + done_completely = 1; + } + else if (atoi(num) == 20) { + move_end(); + num_proc += 6; + done_completely = 1; + } + else if (atoi(num) == 47) { + flip(INS_MODE); + if (INS_MODE) + Cursor_shape(5); + else + Cursor_shape(2); + reprint(curr_pntr); + num_proc = num_proc + 6; + done_completely = 1; + } + else { + insert_buff_nonprinting(6); + done_completely = 1; + } + + break; + } + + default: + insert_buff_nonprinting(1); + break; + } + default: + if (!done_completely) + insert_buff_nonprinting(1); + break; + } + } /* if */ + else { /* ESC w/o [ */ + insert_buff_nonprinting(1); + } + break; + + case _BKSPC: + back_over_current_char(); + num_proc++; + break; + default: + if (in_buff[num_proc] == _KILL) { + delete_line(); + num_proc++; + } + else { + if ((in_buff[num_proc] == _INTR) || (in_buff[num_proc] == _QUIT)) { + write(contNum, &in_buff[num_proc], num_read - num_proc); + if (!PTY) + write(contNum, "\n", 1); + num_proc++; + } + else { + if (in_buff[num_proc] == _EOF) { + insert_buff_nonprinting(1); + if (!PTY) + write(contNum, "\n", 1); + + /*comment out this bit + if (!buff_pntr) { + write(contNum, &in_buff[num_proc], 1); + if (!PTY) + write(contNum, "\n", 1); + } + else { + write(contNum, buff, buff_pntr); + } + */ + num_proc++; + } + else { + if (in_buff[num_proc] == _EOL) { + send_line_to_child(); + if (!PTY) + write(contNum, "\n", 1); + } + else { + if (in_buff[num_proc] == _ERASE) { + back_over_current_char(); + num_proc++; + } + else { + if (control_char(in_buff[num_proc])) + insert_buff_nonprinting(1); + else + insert_buff_printing(1); + } + } + } + } + } /* close the default case */ + break; + } /* switch */ + } /*else*/ + if (had_tab) { + had_tab_last = 1; + had_tab = 0; + } + else + had_tab_last = 0; + + } /* while */ +} + + + +void +send_line_to_child(void) +{ + static char converted_buffer[MAXLINE]; + int converted_num; + + /* Takes care of sending a line to the child, and resetting the + buffer for new input */ + + back_it_up(curr_pntr); + + /* start by putting the line into the command line ring ***/ + if (buff_pntr) + insert_queue(); + + /* finish the line and send it to the child **/ + buff[buff_pntr] = in_buff[num_proc]; + buff_flag[buff_pntr++] = 1; + buff[buff_pntr] = '\0'; + buff_flag[buff_pntr] = -1; + + /* + * Instead of actually writing the Line, I have to substitute in the + * actual characters recieved + */ + converted_num = + convert_buffer(converted_buffer, buff, buff_flag, buff_pntr); + write(contNum, converted_buffer, converted_num); + + /** reinitialize the buffer ***/ + init_flag(buff_flag, buff_pntr); + init_buff(buff, buff_pntr); + /** reinitialize my buffer pointers **/ + buff_pntr = curr_pntr = 0; + + /** reset the ring pointer **/ + current = NULL; + num_proc++; + return; +} + +int +convert_buffer(char *target, char *source,int * source_flag, int num) +{ + int i, j; + + /* + * Until I get something wierd, just keep copying + */ + for (i = 0, j = 0; i < num; i++, j++) { + switch (source[i]) { + case _CARROT: + if (source_flag[i] == 1) { + target[j] = source[i]; + } + else { + if (source[i + 1] == _LBRACK) { + target[j] = _ESC; + i++; + } + else if (source[i + 1] >= 'A' && source[i + 1] <= 'Z') { + target[j] = alpha_to_control(source[i + 1]); + i++; + } + } + break; + case '?': + default: + target[j] = source[i]; + } + } + return j; +} + + +void +insert_buff_printing(int amount) +{ + int count; + + /* This procedure takes the character at in_buff[num_proc] and adds + it to the buffer. It first checks to see if we should be inserting + or overwriting, and then does the appropriate thing */ + + if ((buff_pntr + amount) > 1023) { + putchar(_BELL); + fflush(stdout); + num_proc += amount; + } + else { + + if (INS_MODE) { + + forwardcopy(&buff[curr_pntr + amount], + &buff[curr_pntr], + buff_pntr - curr_pntr); + forwardflag_cpy(&buff_flag[curr_pntr + amount], + &buff_flag[curr_pntr], + buff_pntr - curr_pntr); + for (count = 0; count < amount; count++) { + buff[curr_pntr + count] = in_buff[num_proc + count]; + buff_flag[curr_pntr + count] = 1; + } + ins_print(curr_pntr, amount); + buff_pntr = buff_pntr + amount; + } + else { + for (count = 0; count < amount; count++) { + if (buff_flag[curr_pntr + count] == 2) { + myputchar(buff[curr_pntr + count]); + curr_pntr += count + 1; + delete_current_char(); + /** fix num_proc affected by delete **/ + num_proc -= 3; + curr_pntr -= count + 1; + myputchar(_BKSPC); + } + buff[curr_pntr + count] = in_buff[num_proc + count]; + buff_flag[curr_pntr + count] = 1; + } + myputchar(in_buff[num_proc]); + if (curr_pntr == buff_pntr) + buff_pntr++; + } + num_proc = num_proc + amount; + curr_pntr = curr_pntr + amount; + fflush(stdout); + } + return; + +} + +void +insert_buff_nonprinting(int amount) +{ + int count; + + /* This procedure takes the character at in_buff[num_proc] and adds + it to the buffer. It first checks to see if we should be inserting + or overwriting, and then does the appropriate thing */ + + /* it takes care of the special case, when I have an esc character */ + + if ((buff_pntr + amount) > 1023) { + myputchar(_BELL); + fflush(stdout); + num_proc += amount; + } + else { + if (INS_MODE) { + forwardcopy(&buff[curr_pntr + amount + 1], + &buff[curr_pntr], + buff_pntr - curr_pntr); + forwardflag_cpy(&buff_flag[curr_pntr + amount + 1], + &buff_flag[curr_pntr], + buff_pntr - curr_pntr); + /** now insert the special character **/ + switch (in_buff[num_proc]) { + case _ESC: + /** in this case I insert a '^[' into the string ***/ + buff[curr_pntr] = _CARROT; + buff_flag[curr_pntr] = 2; + buff[curr_pntr + 1] = _LBRACK; + buff_flag[curr_pntr + 1] = 0; + break; + default: + if (control_char(in_buff[num_proc])) { + buff[curr_pntr] = _CARROT; + buff_flag[curr_pntr] = 2; + buff[curr_pntr + 1] = control_to_alpha(in_buff[num_proc]); + buff_flag[curr_pntr + 1] = 0; + } + else { + /** What do I have ? **/ + buff[curr_pntr] = '?'; + buff_flag[curr_pntr] = 2; + buff[curr_pntr + 1] = in_buff[num_proc]; + buff_flag[curr_pntr] = 0; + break; + } + } + /** Now add the normal characters **/ + for (count = 1; count < amount; count++) { + buff[curr_pntr + count + 1] = in_buff[num_proc + count]; + buff_flag[curr_pntr + count + 1] = 1; + } + ins_print(curr_pntr, amount + 1); + buff_pntr = buff_pntr + amount + 1; + } + else { + /** I am in the overstrike mode **/ + switch (in_buff[num_proc]) { + case _ESC: + /** in this case I insert a '^[' into the string ***/ + buff[curr_pntr] = _CARROT; + buff_flag[curr_pntr] = 2; + buff[curr_pntr + 1] = _LBRACK; + buff_flag[curr_pntr + 1] = 0; + break; + default: + if (control_char(in_buff[num_proc])) { + buff[curr_pntr] = _CARROT; + buff_flag[curr_pntr] = 2; + buff[curr_pntr + 1] = control_to_alpha(in_buff[num_proc]); + buff_flag[curr_pntr + 1] = 0; + } + else { + /** What do I have ? **/ + buff[curr_pntr] = '?'; + buff_flag[curr_pntr] = 2; + buff[curr_pntr + 1] = in_buff[num_proc]; + buff_flag[curr_pntr] = 0; + break; + } + } + for (count = 1; count < amount; count++) { + if (buff_flag[curr_pntr + count] == 2) { + curr_pntr += count + 1; + delete_current_char(); + /** fix num. processed form delete **/ + num_proc -= 3; + curr_pntr -= count + 1; + } + buff[curr_pntr + count + 1] = in_buff[num_proc + count]; + buff_flag[curr_pntr + count + 1] = 1; + } + /** now print the characters I have put in **/ + printbuff(curr_pntr, amount + 1); + } + num_proc = num_proc + amount; + curr_pntr = curr_pntr + amount + 1; + if (curr_pntr > buff_pntr) + buff_pntr = curr_pntr; + } + return; + +} + +void +prev_buff(void) +{ + + /* + * If the current command ring is NULL, then I should NOT clear the + * current line. Thus my business is already done + */ + if (ring == NULL) + return; + clear_buff(); + init_buff(buff, buff_pntr); + init_flag(buff_flag, buff_pntr); + + if (current == NULL) { + if (ring == NULL) + return; + current = ring; + } + else + current = current->prev; + strcpy(buff, current->buff); + flagcpy(buff_flag, current->flags); + + /* first back up and blank the line */ + fflush(stdout); + printbuff(0, strlen(buff)); + curr_pntr = buff_pntr = strlen(buff); + fflush(stdout); + return ; +} + +void +next_buff(void) +{ + + /* + * If the current command ring is NULL, then I should NOT clear the + * current line. Thus my business is already done + */ + if (ring == NULL) + return; + clear_buff(); + init_buff(buff, buff_pntr); + init_flag(buff_flag, buff_pntr); + if (current == NULL) { + if (ring == NULL) + return; + current = ring->next; + } + else + current = current->next; + strcpy(buff, current->buff); + flagcpy(buff_flag, current->flags); + + /* first back up and blank the line **/ + fflush(stdout); + printbuff(0, strlen(buff)); + curr_pntr = buff_pntr = strlen(buff); + fflush(stdout); + return ; +} + + +void +forwardcopy(char *buff1,char * buff2,int num) +{ + int count; + + for (count = num; count >= 0; count--) + buff1[count] = buff2[count]; +} + + +void +forwardflag_cpy(int *buff1,int * buff2,int num) +{ + int count; + + for (count = num; count >= 0; count--) + buff1[count] = buff2[count]; +} + +void +flagcpy(int *s,int *t) +{ + while (*t >= 0) + *s++ = *t++; + *s = *t; +} + +void +flagncpy(int *s,int *t,int n) +{ + while (n-- > 0) + *s++ = *t++; +} + +void +insert_queue(void) +{ + QueStruct *trace; + QueStruct *new; + int c; + + if (!ECHOIT) + return; + if (ring != NULL && !strcmp(buff, ring->buff)) + return; + for (c = 0, trace = ring; trace != NULL && c < (prev_check - 1); + c++, trace = trace->prev) { + if (!strcmp(buff, trace->buff)) { + + /* + * throw this puppy at the end of the ring + */ + trace->next->prev = trace->prev; + trace->prev->next = trace->next; + trace->prev = ring; + trace->next = ring->next; + ring->next = trace; + trace->next->prev = trace; + ring = trace; + return; + } + } + + /* + * simply places the buff command into the front of the queue + */ + if (ring_size < MAXRING) { + new = (QueStruct *) malloc(sizeof(struct que_struct)); + if (new == NULL) { + fprintf(stderr, "Malloc Error: Ran out of memory\n"); + exit(-1); + } + if (ring_size == 0) { + ring = new; + ring->prev = ring->next = new; + } + else { + new->next = ring->next; + new->prev = ring; + ring->next = new; + new->next->prev = new; + ring = new; + } + ring_size++; + } + else + ring = ring->next; + + init_flag(ring->flags, MAXLINE); + init_buff(ring->buff, MAXLINE); + strcpy(ring->buff, buff); + flagncpy(ring->flags, buff_flag, buff_pntr); + (ring->buff)[buff_pntr] = '\0'; + (ring->flags)[buff_pntr] = -1; +} + + +void +init_flag(int *flags, int num) +{ + int i; + + for (i = 0; i < num; i++) + flags[i] = -1; +} + +void +init_buff(char *flags, int num) +{ + int i; + + for (i = 0; i < num; i++) + flags[i] = '\0'; +} + + +void +send_function_to_child(void) +{ + /* Takes care of sending a line to the child, and resetting the + buffer for new input */ + + back_it_up(curr_pntr); + /** start by putting the line into the command line ring ***/ + if (buff_pntr) + insert_queue(); + + /** finish the line and send it to the child **/ + buff[buff_pntr] = _EOLN; + + buff_flag[buff_pntr++] = 1; + buff[buff_pntr] = '\0'; + buff_flag[buff_pntr] = 0; + write(contNum, buff, buff_pntr); + + /** reinitialize the buffer ***/ + init_flag(buff_flag, buff_pntr); + init_buff(buff, buff_pntr); + /** reinitialize my buffer pointers **/ + buff_pntr = curr_pntr = 0; + + /** reset the ring pointer **/ + current = NULL; + + num_proc++; + return; +} + +void +send_buff_to_child(int chann) +{ + if (buff_pntr > 0) + write(chann, buff, buff_pntr); + num_proc += 6; + /** reinitialize the buffer ***/ + init_flag(buff_flag, buff_pntr); + init_buff(buff, buff_pntr); + /** reinitialize my buffer pointers **/ + buff_pntr = curr_pntr = 0; + /** reset the ring pointer **/ + current = NULL; + return; +} + diff --git a/src/lib/edin.c.pamphlet b/src/lib/edin.c.pamphlet deleted file mode 100644 index 97b9143a..00000000 --- a/src/lib/edin.c.pamphlet +++ /dev/null @@ -1,971 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib edin.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -/* #define debug 1 */ - -#include -#include "axiom-c-macros.h" -@ -The MACOSX platform is broken because no matter what you do it seems to -include files from [[/usr/include/sys]] ahead of [[/usr/include]]. On linux -systems these files include themselves which causes an infinite regression -of includes that fails. GCC gracefully steps over that problem but the -build fails anyway. On MACOSX the [[/usr/include/sys]] versions -of files are badly broken with respect to the [[/usr/include]] versions. -<<*>>= -#if defined(MACOSXplatform) -#include "/usr/include/unistd.h" -#else -#include -#endif -#include -#include -#include - -#include "edible.h" - -#define HFT 0 -#define SUN 1 -#define DEC 2 -#define control_to_alpha(x) (x + ('A' - 0x01)) -#define alpha_to_control(x) (x - ('A' - 0x01)) - -int termId; -QueStruct *ring = NULL; -QueStruct *current = NULL; -int ring_size = 0; -int MAXRING = 64; -int prev_check = 10; -int curr_pntr; -int num_pntr; -int num_proc; -int had_tab; -int had_tab_last; -extern char buff[1024]; /* Buffers for collecting input and */ -extern int buff_flag[1024]; /* flags for whether buff chars - are printing or non-printing */ -int buff_pntr; /* present length of buff */ - - -#include "edin.H1" -#include "prt.H1" -#include "wct.H1" -#include "cursor.H1" -#include "fnct_key.H1" - - - -void -init_reader(void) -{ - char *termVal; - - buff[50] = '\0'; /** initialize some stuff ***/ - init_flag(buff_flag, MAXLINE); - buff_pntr = curr_pntr = 0; - - had_tab = 0; - had_tab_last = 0; - termVal = (char *) getenv("TERM"); - if (!strcmp("sun", termVal)) - termId = SUN; - else if (!strcmp("xterm", termVal) || !strncmp("vt", termVal, 2)) - termId = DEC; - else if (!strcmp("hft", termVal) || !strncmp("aixterm", termVal, 7)) - termId = HFT; -} - - -void -do_reading(void) -{ - int ttt_read; - int done_completely; - - done_completely = 0; - num_proc = 0; - while (num_proc < num_read) { - if(in_buff[num_proc]== _ERASE) { - back_over_current_char(); - num_proc++; - } - else { - switch (in_buff[num_proc]) { - /* lets start checking for different types of chars */ - case _EOLN: - case _CR: - /* If I have read a complete line, so send it to the child */ - send_line_to_child(); - if (!PTY) - myputchar('\n'); - break; - - /* - * Use 0x7f as delete - */ - case _DEL: - /* Had a delete key */ - delete_current_char(); - break; - - case _CNTRL_W: - move_back_word(); - num_proc++; - break; - case _TAB: - had_tab = 1; - /* command completion stuff */ - num_proc++; - if (had_tab_last) - rescan_wct(); - else - find_wct(); - break; - case _BELL: - insert_buff_nonprinting(1); - putchar(_BELL); - fflush(stdout); - break; - case _ESC: - - /* - * get 2 characters more - */ - while (!(num_read - num_proc > 2)) { - ttt_read = read(0, - in_buff + num_read, - 2 - (num_read - num_proc) + 1); - if (ttt_read > 0) - num_read = num_read + ttt_read; - } - if ((in_buff[num_proc + 1] == _LBRACK)) { - - /* ESC [ */ - - switch (in_buff[num_proc + 2]) { - /* look for arrows */ - case _A: - /* up arrow */ - - /* - * The first thing I plan to do is get rid of the present - * input ** - */ - prev_buff(); - curr_pntr = buff_pntr; - num_proc = num_proc + 3; - break; - case _B: - /* down arrow */ - next_buff(); - curr_pntr = buff_pntr; - num_proc = num_proc + 3; - break; - case _C: - /* right arrow */ - move_ahead(); - num_proc = num_proc + 3; - break; - case _D: - /* left arrow */ - move_back(); - num_proc = num_proc + 3; - break; - - /* - * Use ^[[P as delete - */ - case _P: - /*** Had a delete key ****/ - delete_current_char(); - break; - case _H: - case 0: - move_home(); - num_proc += 3; - break; - case _M: - case _Z: - insert_buff_nonprinting(3); - done_completely = 1; - num_proc += 3; - break; - case _x: - num_proc = num_read; - break; - case _1: - case _2: - case _0: - - /* - * I have had a possible function key hit, look for the - * ones I want. check for ESC ] x ~ - */ - while (!(num_read - num_proc > 3)) { - ttt_read = read(0, - in_buff + num_read, - 3 - (num_read - num_proc) + 1); - if (ttt_read > 0) - num_read = num_read + ttt_read; - } - if (in_buff[num_proc + 3] == _twiddle) { - - /* - * treat ESC ] x ~ - */ - switch (in_buff[num_proc + 2]) { - case _2: - flip(INS_MODE); - if (INS_MODE) - Cursor_shape(5); - else - Cursor_shape(2); - reprint(curr_pntr); - num_proc += 4; - break; - default: - insert_buff_nonprinting(1); - break; - } - break; - } - /* check for ESC ] x y ~ */ - while (!(num_read - num_proc > 4)) { - ttt_read = read(0, - in_buff + num_read, - 4 - (num_read - num_proc) + 1); - if (ttt_read > 0) - num_read = num_read + ttt_read; - } - if (in_buff[num_proc + 4] == _twiddle) { - - /* - * treat ESC ] x y ~ - */ - insert_buff_nonprinting(1); - break; - } - - /* check for ESC ] x y z [q|z] */ - - while (!(num_read - num_proc > 5)) { - ttt_read = read(0, - in_buff + num_read, - 5 - (num_read - num_proc) + 1); - if (ttt_read > 0) - num_read = num_read + ttt_read; - } - if (insert_toggle(&in_buff[num_proc + 3])) { - flip(INS_MODE); - if (INS_MODE) - Cursor_shape(5); - else - Cursor_shape(2); - reprint(curr_pntr); - num_proc = num_proc + 6; - break; - } - else if (cntrl_end(&in_buff[num_proc + 3])) { - num_proc = num_proc + 6; - delete_to_end_of_line(); - break; - } - else if (back_word(&in_buff[num_proc + 3])) { - move_back_word(); - num_proc += 6; - break; - } - else if (fore_word(&in_buff[num_proc + 3])) { - move_fore_word(); - num_proc += 6; - break; - } - else if (end_key(&in_buff[num_proc + 3])) { - move_end(); - num_proc += 6; - break; - } - switch (in_buff[num_proc + 5]) { - case _q: - - /* - * IBM function keys - */ - { - char num[3]; - int key; - - num[0] = in_buff[num_proc + 3]; - num[1] = in_buff[num_proc + 4]; - num[2] = '\0'; - key = atoi(num); - if (key > 0 && key < 13) { - if (function_key[key].str != NULL) { - handle_function_key(key, contNum); - done_completely = 1; - } - else { - insert_buff_nonprinting(6); - done_completely = 1; - } - } - else { - insert_buff_nonprinting(6); - done_completely = 1; - } - break; - } - case _z: - - /* - * Sun function keys - */ - { - char num[3]; - int key; - - num[0] = in_buff[num_proc + 3]; - num[1] = in_buff[num_proc + 4]; - num[2] = '\0'; - key = atoi(num) - 23; - if (key > 0 && key < 13) { - if (function_key[key].str != NULL) { - handle_function_key(key, contNum); - done_completely = 1; - } - else { - insert_buff_nonprinting(6); - done_completely = 1; - } - } - else if (atoi(num) == 14) { - move_home(); - num_proc += 6; - done_completely = 1; - } - else if (atoi(num) == 20) { - move_end(); - num_proc += 6; - done_completely = 1; - } - else if (atoi(num) == 47) { - flip(INS_MODE); - if (INS_MODE) - Cursor_shape(5); - else - Cursor_shape(2); - reprint(curr_pntr); - num_proc = num_proc + 6; - done_completely = 1; - } - else { - insert_buff_nonprinting(6); - done_completely = 1; - } - - break; - } - - default: - insert_buff_nonprinting(1); - break; - } - default: - if (!done_completely) - insert_buff_nonprinting(1); - break; - } - } /* if */ - else { /* ESC w/o [ */ - insert_buff_nonprinting(1); - } - break; - - case _BKSPC: - back_over_current_char(); - num_proc++; - break; - default: - if (in_buff[num_proc] == _KILL) { - delete_line(); - num_proc++; - } - else { - if ((in_buff[num_proc] == _INTR) || (in_buff[num_proc] == _QUIT)) { - write(contNum, &in_buff[num_proc], num_read - num_proc); - if (!PTY) - write(contNum, "\n", 1); - num_proc++; - } - else { - if (in_buff[num_proc] == _EOF) { - insert_buff_nonprinting(1); - if (!PTY) - write(contNum, "\n", 1); - - /*comment out this bit - if (!buff_pntr) { - write(contNum, &in_buff[num_proc], 1); - if (!PTY) - write(contNum, "\n", 1); - } - else { - write(contNum, buff, buff_pntr); - } - */ - num_proc++; - } - else { - if (in_buff[num_proc] == _EOL) { - send_line_to_child(); - if (!PTY) - write(contNum, "\n", 1); - } - else { - if (in_buff[num_proc] == _ERASE) { - back_over_current_char(); - num_proc++; - } - else { - if (control_char(in_buff[num_proc])) - insert_buff_nonprinting(1); - else - insert_buff_printing(1); - } - } - } - } - } /* close the default case */ - break; - } /* switch */ - } /*else*/ - if (had_tab) { - had_tab_last = 1; - had_tab = 0; - } - else - had_tab_last = 0; - - } /* while */ -} - - - -void -send_line_to_child(void) -{ - static char converted_buffer[MAXLINE]; - int converted_num; - - /* Takes care of sending a line to the child, and resetting the - buffer for new input */ - - back_it_up(curr_pntr); - - /* start by putting the line into the command line ring ***/ - if (buff_pntr) - insert_queue(); - - /* finish the line and send it to the child **/ - buff[buff_pntr] = in_buff[num_proc]; - buff_flag[buff_pntr++] = 1; - buff[buff_pntr] = '\0'; - buff_flag[buff_pntr] = -1; - - /* - * Instead of actually writing the Line, I have to substitute in the - * actual characters recieved - */ - converted_num = - convert_buffer(converted_buffer, buff, buff_flag, buff_pntr); - write(contNum, converted_buffer, converted_num); - - /** reinitialize the buffer ***/ - init_flag(buff_flag, buff_pntr); - init_buff(buff, buff_pntr); - /** reinitialize my buffer pointers **/ - buff_pntr = curr_pntr = 0; - - /** reset the ring pointer **/ - current = NULL; - num_proc++; - return; -} - -int -convert_buffer(char *target, char *source,int * source_flag, int num) -{ - int i, j; - - /* - * Until I get something wierd, just keep copying - */ - for (i = 0, j = 0; i < num; i++, j++) { - switch (source[i]) { - case _CARROT: - if (source_flag[i] == 1) { - target[j] = source[i]; - } - else { - if (source[i + 1] == _LBRACK) { - target[j] = _ESC; - i++; - } - else if (source[i + 1] >= 'A' && source[i + 1] <= 'Z') { - target[j] = alpha_to_control(source[i + 1]); - i++; - } - } - break; - case '?': - default: - target[j] = source[i]; - } - } - return j; -} - - -void -insert_buff_printing(int amount) -{ - int count; - - /* This procedure takes the character at in_buff[num_proc] and adds - it to the buffer. It first checks to see if we should be inserting - or overwriting, and then does the appropriate thing */ - - if ((buff_pntr + amount) > 1023) { - putchar(_BELL); - fflush(stdout); - num_proc += amount; - } - else { - - if (INS_MODE) { - - forwardcopy(&buff[curr_pntr + amount], - &buff[curr_pntr], - buff_pntr - curr_pntr); - forwardflag_cpy(&buff_flag[curr_pntr + amount], - &buff_flag[curr_pntr], - buff_pntr - curr_pntr); - for (count = 0; count < amount; count++) { - buff[curr_pntr + count] = in_buff[num_proc + count]; - buff_flag[curr_pntr + count] = 1; - } - ins_print(curr_pntr, amount); - buff_pntr = buff_pntr + amount; - } - else { - for (count = 0; count < amount; count++) { - if (buff_flag[curr_pntr + count] == 2) { - myputchar(buff[curr_pntr + count]); - curr_pntr += count + 1; - delete_current_char(); - /** fix num_proc affected by delete **/ - num_proc -= 3; - curr_pntr -= count + 1; - myputchar(_BKSPC); - } - buff[curr_pntr + count] = in_buff[num_proc + count]; - buff_flag[curr_pntr + count] = 1; - } - myputchar(in_buff[num_proc]); - if (curr_pntr == buff_pntr) - buff_pntr++; - } - num_proc = num_proc + amount; - curr_pntr = curr_pntr + amount; - fflush(stdout); - } - return; - -} - -void -insert_buff_nonprinting(int amount) -{ - int count; - - /* This procedure takes the character at in_buff[num_proc] and adds - it to the buffer. It first checks to see if we should be inserting - or overwriting, and then does the appropriate thing */ - - /* it takes care of the special case, when I have an esc character */ - - if ((buff_pntr + amount) > 1023) { - myputchar(_BELL); - fflush(stdout); - num_proc += amount; - } - else { - if (INS_MODE) { - forwardcopy(&buff[curr_pntr + amount + 1], - &buff[curr_pntr], - buff_pntr - curr_pntr); - forwardflag_cpy(&buff_flag[curr_pntr + amount + 1], - &buff_flag[curr_pntr], - buff_pntr - curr_pntr); - /** now insert the special character **/ - switch (in_buff[num_proc]) { - case _ESC: - /** in this case I insert a '^[' into the string ***/ - buff[curr_pntr] = _CARROT; - buff_flag[curr_pntr] = 2; - buff[curr_pntr + 1] = _LBRACK; - buff_flag[curr_pntr + 1] = 0; - break; - default: - if (control_char(in_buff[num_proc])) { - buff[curr_pntr] = _CARROT; - buff_flag[curr_pntr] = 2; - buff[curr_pntr + 1] = control_to_alpha(in_buff[num_proc]); - buff_flag[curr_pntr + 1] = 0; - } - else { - /** What do I have ? **/ - buff[curr_pntr] = '?'; - buff_flag[curr_pntr] = 2; - buff[curr_pntr + 1] = in_buff[num_proc]; - buff_flag[curr_pntr] = 0; - break; - } - } - /** Now add the normal characters **/ - for (count = 1; count < amount; count++) { - buff[curr_pntr + count + 1] = in_buff[num_proc + count]; - buff_flag[curr_pntr + count + 1] = 1; - } - ins_print(curr_pntr, amount + 1); - buff_pntr = buff_pntr + amount + 1; - } - else { - /** I am in the overstrike mode **/ - switch (in_buff[num_proc]) { - case _ESC: - /** in this case I insert a '^[' into the string ***/ - buff[curr_pntr] = _CARROT; - buff_flag[curr_pntr] = 2; - buff[curr_pntr + 1] = _LBRACK; - buff_flag[curr_pntr + 1] = 0; - break; - default: - if (control_char(in_buff[num_proc])) { - buff[curr_pntr] = _CARROT; - buff_flag[curr_pntr] = 2; - buff[curr_pntr + 1] = control_to_alpha(in_buff[num_proc]); - buff_flag[curr_pntr + 1] = 0; - } - else { - /** What do I have ? **/ - buff[curr_pntr] = '?'; - buff_flag[curr_pntr] = 2; - buff[curr_pntr + 1] = in_buff[num_proc]; - buff_flag[curr_pntr] = 0; - break; - } - } - for (count = 1; count < amount; count++) { - if (buff_flag[curr_pntr + count] == 2) { - curr_pntr += count + 1; - delete_current_char(); - /** fix num. processed form delete **/ - num_proc -= 3; - curr_pntr -= count + 1; - } - buff[curr_pntr + count + 1] = in_buff[num_proc + count]; - buff_flag[curr_pntr + count + 1] = 1; - } - /** now print the characters I have put in **/ - printbuff(curr_pntr, amount + 1); - } - num_proc = num_proc + amount; - curr_pntr = curr_pntr + amount + 1; - if (curr_pntr > buff_pntr) - buff_pntr = curr_pntr; - } - return; - -} - -void -prev_buff(void) -{ - - /* - * If the current command ring is NULL, then I should NOT clear the - * current line. Thus my business is already done - */ - if (ring == NULL) - return; - clear_buff(); - init_buff(buff, buff_pntr); - init_flag(buff_flag, buff_pntr); - - if (current == NULL) { - if (ring == NULL) - return; - current = ring; - } - else - current = current->prev; - strcpy(buff, current->buff); - flagcpy(buff_flag, current->flags); - - /* first back up and blank the line */ - fflush(stdout); - printbuff(0, strlen(buff)); - curr_pntr = buff_pntr = strlen(buff); - fflush(stdout); - return ; -} - -void -next_buff(void) -{ - - /* - * If the current command ring is NULL, then I should NOT clear the - * current line. Thus my business is already done - */ - if (ring == NULL) - return; - clear_buff(); - init_buff(buff, buff_pntr); - init_flag(buff_flag, buff_pntr); - if (current == NULL) { - if (ring == NULL) - return; - current = ring->next; - } - else - current = current->next; - strcpy(buff, current->buff); - flagcpy(buff_flag, current->flags); - - /* first back up and blank the line **/ - fflush(stdout); - printbuff(0, strlen(buff)); - curr_pntr = buff_pntr = strlen(buff); - fflush(stdout); - return ; -} - - -void -forwardcopy(char *buff1,char * buff2,int num) -{ - int count; - - for (count = num; count >= 0; count--) - buff1[count] = buff2[count]; -} - - -void -forwardflag_cpy(int *buff1,int * buff2,int num) -{ - int count; - - for (count = num; count >= 0; count--) - buff1[count] = buff2[count]; -} - -void -flagcpy(int *s,int *t) -{ - while (*t >= 0) - *s++ = *t++; - *s = *t; -} - -void -flagncpy(int *s,int *t,int n) -{ - while (n-- > 0) - *s++ = *t++; -} - -void -insert_queue(void) -{ - QueStruct *trace; - QueStruct *new; - int c; - - if (!ECHOIT) - return; - if (ring != NULL && !strcmp(buff, ring->buff)) - return; - for (c = 0, trace = ring; trace != NULL && c < (prev_check - 1); - c++, trace = trace->prev) { - if (!strcmp(buff, trace->buff)) { - - /* - * throw this puppy at the end of the ring - */ - trace->next->prev = trace->prev; - trace->prev->next = trace->next; - trace->prev = ring; - trace->next = ring->next; - ring->next = trace; - trace->next->prev = trace; - ring = trace; - return; - } - } - - /* - * simply places the buff command into the front of the queue - */ - if (ring_size < MAXRING) { - new = (QueStruct *) malloc(sizeof(struct que_struct)); - if (new == NULL) { - fprintf(stderr, "Malloc Error: Ran out of memory\n"); - exit(-1); - } - if (ring_size == 0) { - ring = new; - ring->prev = ring->next = new; - } - else { - new->next = ring->next; - new->prev = ring; - ring->next = new; - new->next->prev = new; - ring = new; - } - ring_size++; - } - else - ring = ring->next; - - init_flag(ring->flags, MAXLINE); - init_buff(ring->buff, MAXLINE); - strcpy(ring->buff, buff); - flagncpy(ring->flags, buff_flag, buff_pntr); - (ring->buff)[buff_pntr] = '\0'; - (ring->flags)[buff_pntr] = -1; -} - - -void -init_flag(int *flags, int num) -{ - int i; - - for (i = 0; i < num; i++) - flags[i] = -1; -} - -void -init_buff(char *flags, int num) -{ - int i; - - for (i = 0; i < num; i++) - flags[i] = '\0'; -} - - -void -send_function_to_child(void) -{ - /* Takes care of sending a line to the child, and resetting the - buffer for new input */ - - back_it_up(curr_pntr); - /** start by putting the line into the command line ring ***/ - if (buff_pntr) - insert_queue(); - - /** finish the line and send it to the child **/ - buff[buff_pntr] = _EOLN; - - buff_flag[buff_pntr++] = 1; - buff[buff_pntr] = '\0'; - buff_flag[buff_pntr] = 0; - write(contNum, buff, buff_pntr); - - /** reinitialize the buffer ***/ - init_flag(buff_flag, buff_pntr); - init_buff(buff, buff_pntr); - /** reinitialize my buffer pointers **/ - buff_pntr = curr_pntr = 0; - - /** reset the ring pointer **/ - current = NULL; - - num_proc++; - return; -} - -void -send_buff_to_child(int chann) -{ - if (buff_pntr > 0) - write(chann, buff, buff_pntr); - num_proc += 6; - /** reinitialize the buffer ***/ - init_flag(buff_flag, buff_pntr); - init_buff(buff, buff_pntr); - /** reinitialize my buffer pointers **/ - buff_pntr = curr_pntr = 0; - /** reset the ring pointer **/ - current = NULL; - return; -} - -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/fnct_key.c b/src/lib/fnct_key.c new file mode 100644 index 00000000..a44f0bf5 --- /dev/null +++ b/src/lib/fnct_key.c @@ -0,0 +1,357 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" +#if defined(MACOSXplatform) +#include "/usr/include/unistd.h" +#else +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include + + +#include "edible.h" +#include "bsdsignal.h" + + +#include "bsdsignal.H1" +#include "fnct_key.H1" +#include "prt.H1" +#include "edin.H1" + + +/** Some constants for functio key defs ****/ +#define DELAYED 0 +#define IMMEDIATE 1 +#define SPECIAL 2 + + +/** Here is the structure for storing bound pf-keys ***/ +fkey function_key[13]; /** Strings which replace function + keys when a key is hit ***/ + +static char *defaulteditor = "clefedit"; +char editorfilename[100]; + + + +/* + * The following function environment variable clef editor. The command + * should be the one that the user wishes to have execed + */ + +void +set_editor_key(void) +{ + int pid; + + sprintf(editorfilename, "/tmp/clef%d", pid = getpid()); + + if (function_key[12].str == NULL) { + (function_key[12]).type = SPECIAL; + (function_key[12]).str = defaulteditor; + } +} + + + + +/*** This routine id used to find the users function key mappings. It + simply searches the users HOME directory for a file called ".clef". + If found it gets the key bindings from within + *****/ + +void +define_function_keys(void) +{ + char *HOME, path[1024], string[1024]; + int key; + int fd; + char type; + int length; + + /** lets initialize the key pointers **/ + for (key = 0; key < 13; key++) + (function_key[key]).str = NULL; + /** see if the user has a .clef file ***/ + HOME = getenv("HOME"); + sprintf(path, "%s/.clef", HOME); + if ((fd = open(path, O_RDONLY)) == -1) { + return; + } + else { + /*** If so, then get the key bindings **/ + while ((key = get_key(fd, &type))) { + length = get_str(fd, string); + switch (type) { + case 'D': + if (key == 12) { + fprintf(stderr, + "Clef Error: PF12 can only be of type E in .clef\n"); + fprintf(stderr, "Line will be ignored\n"); + type = -1; + } + else { + (function_key[key]).type = DELAYED; + } + break; + case 'F': + if (key == 12) { + fprintf(stderr, + "Clef Error: PF12 can only be of type E in .clef\n"); + fprintf(stderr, "Line will be ignored\n"); + type = -1; + } + else { + (function_key[key]).type = IMMEDIATE; + } + break; + case 'E': + if (key != 12) { + fprintf(stderr, + "Clef Error: PF12 can only be of type E in .clef\n"); + fprintf(stderr, "Line will be ignored\n"); + type = -1; + } + else { + (function_key[key]).type = SPECIAL; + } + break; + } + if (type != -1) { + (function_key[key]).str = + (char *) malloc(strlen(string) + 1); + sprintf((function_key[key]).str, "%s", string); + } + } + } + + /* + * Now set the editor function key + */ + set_editor_key(); +} + + +#define defof(c) ((c == 'F' || c == 'D' || c == 'E')?(1):(0)) + +int +get_key(int fd,char * ty) +{ + + /* + * Determines the key number being mapped, and whether it is immediate or + * delay. It reurns the key value, and modifies the parameter type + */ + char keynum[1024]; + int nr; + + nr = read(fd, keynum, 3); + if (nr != -1 && nr != 0) { + if (!defof(keynum[0])) { + return 0; + } + else { + *ty = keynum[0]; + keynum[3] = '\0'; + return (atoi(&keynum[1])); + } + } + else + return 0; +} + +int +get_str(int fd,char * string) +{ + /** Gets the key mapping being bound **/ + char c; + int count = 0; + char *trace = string; + + read(fd, &c, 1); + while (c == ' ') + read(fd, &c, 1); + while (c != '\n') { + count++; + *trace++ = c; + if (read(fd, &c, 1) == 0) + break; + } + *trace = '\0'; + return count; +} + +void +null_fnct(int sig) +{ + return; +} + +void +handle_function_key(int key,int chann) +{ + /** this procedure simply adds the string specified by the function key + to the buffer ****/ + int count, fd; + int amount = strlen(function_key[key].str); + int id; + int save_echo; + + /*** This procedure takes the character at in_buff[num_proc] and adds + it to the buffer. It first checks to see if we should be inserting + or overwriting, and then does the appropriate thing *******/ + + switch ((function_key[key]).type) { + case IMMEDIATE: + if (INS_MODE) { + forwardcopy(&buff[curr_pntr + amount], + &buff[curr_pntr], + buff_pntr - curr_pntr); + forwardflag_cpy(&buff_flag[curr_pntr + amount], + &buff_flag[curr_pntr], + buff_pntr - curr_pntr); + for (count = 0; count < amount; count++) { + buff[curr_pntr + count] = (function_key[key].str)[count]; + buff_flag[curr_pntr + count] = '1'; + } + ins_print(curr_pntr, amount + 1); + buff_pntr = buff_pntr + amount; + } + else { + for (count = 0; count < amount; count++) { + buff[curr_pntr + count] = (function_key[key].str)[count]; + buff_flag[curr_pntr + count] = '1'; + myputchar((function_key[key].str)[count]); + } + } + num_proc = num_proc + 6; + curr_pntr = curr_pntr + amount; + buff_pntr = buff_pntr + amount; + send_function_to_child(); + break; + case DELAYED: + if (INS_MODE) { + forwardcopy(&buff[curr_pntr + amount], + &buff[curr_pntr], + buff_pntr - curr_pntr); + forwardflag_cpy(&buff_flag[curr_pntr + amount], + &buff_flag[curr_pntr], + buff_pntr - curr_pntr); + for (count = 0; count < amount; count++) { + buff[curr_pntr + count] = (function_key[key].str)[count]; + buff_flag[curr_pntr + count] = '1'; + } + ins_print(curr_pntr, amount + 1); + buff_pntr = buff_pntr + amount; + } + else { + for (count = 0; count < amount; count++) { + buff[curr_pntr + count] = (function_key[key].str)[count]; + buff_flag[curr_pntr + count] = '1'; + myputchar((function_key[key].str)[count]); + } + } + num_proc = num_proc + 6; + curr_pntr = curr_pntr + amount; + buff_pntr = buff_pntr + amount; + fflush(stdout); + break; + case SPECIAL: + /* fprintf(stderr, "Here I am \n"); */ + if (access(editorfilename, F_OK) < 0) { + fd = open(editorfilename, O_RDWR | O_CREAT, 0666); + write(fd, buff, buff_pntr); + back_up(buff_pntr); + close(fd); + } + else { + if (buff_pntr > 0) { + fd = open(editorfilename, O_RDWR | O_TRUNC); + write(fd, buff, buff_pntr); + back_up(buff_pntr); + close(fd); + } + } +#if defined(MACOSXplatform) || defined(BSDplatform) + bsdSignal(SIGCHLD, null_fnct,RestartSystemCalls); +#else + bsdSignal(SIGCLD, null_fnct,RestartSystemCalls); +#endif + switch (id = fork()) { + case -1: + perror("Special key"); + break; + case 0: + execlp((function_key[12]).str, + (function_key[12]).str, + editorfilename, NULL); + perror("Returned from exec"); + exit(0); + + } + while (wait((int *) 0) < 0); + /** now I should read that file and send all it stuff thru the + reader *****/ + fd = open(editorfilename, O_RDWR); + if (fd == -1) { + perror("Opening temp file"); + exit(-1); + } + num_proc += 6; + + /** reinitialize the buffer ***/ + init_flag(buff_flag, buff_pntr); + init_buff(buff, buff_pntr); + /** reinitialize my buffer pointers **/ + buff_pntr = curr_pntr = 0; + /** reset the ring pointer **/ + current = NULL; + save_echo = ECHOIT; + ECHOIT = 0; + while ((num_read = read(fd, in_buff, MAXLINE))) { + do_reading(); + } + close(fd); + break; + } + return; + +} diff --git a/src/lib/fnct_key.c.pamphlet b/src/lib/fnct_key.c.pamphlet deleted file mode 100644 index 576b89ac..00000000 --- a/src/lib/fnct_key.c.pamphlet +++ /dev/null @@ -1,395 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib fnct\_key.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{MAC OSX and BSD port} -On the MAC OSX the signal [[SIGCLD]] has been renamed to [[SIGCHLD]]. -In order to handle this change we need to ensure that the platform -variable is set properly and that the platform variable is changed -everywhere. -<>= -#if defined(MACOSXplatform) || defined(BSDplatform) - bsdSignal(SIGCHLD, null_fnct,RestartSystemCalls); -#else - bsdSignal(SIGCLD, null_fnct,RestartSystemCalls); -#endif -@ -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -@ -The MACOSX platform is broken because no matter what you do it seems to -include files from [[/usr/include/sys]] ahead of [[/usr/include]]. On linux -systems these files include themselves which causes an infinite regression -of includes that fails. GCC gracefully steps over that problem but the -build fails anyway. On MACOSX the [[/usr/include/sys]] versions -of files are badly broken with respect to the [[/usr/include]] versions. -<<*>>= -#if defined(MACOSXplatform) -#include "/usr/include/unistd.h" -#else -#include -#endif -#include -#include -#include -#include -#include -#include -#include -#include - - -#include "edible.h" -#include "bsdsignal.h" - - -#include "bsdsignal.H1" -#include "fnct_key.H1" -#include "prt.H1" -#include "edin.H1" - - -/** Some constants for functio key defs ****/ -#define DELAYED 0 -#define IMMEDIATE 1 -#define SPECIAL 2 - - -/** Here is the structure for storing bound pf-keys ***/ -fkey function_key[13]; /** Strings which replace function - keys when a key is hit ***/ - -static char *defaulteditor = "clefedit"; -char editorfilename[100]; - - - -/* - * The following function environment variable clef editor. The command - * should be the one that the user wishes to have execed - */ - -void -set_editor_key(void) -{ - int pid; - - sprintf(editorfilename, "/tmp/clef%d", pid = getpid()); - - if (function_key[12].str == NULL) { - (function_key[12]).type = SPECIAL; - (function_key[12]).str = defaulteditor; - } -} - - - - -/*** This routine id used to find the users function key mappings. It - simply searches the users HOME directory for a file called ".clef". - If found it gets the key bindings from within - *****/ - -void -define_function_keys(void) -{ - char *HOME, path[1024], string[1024]; - int key; - int fd; - char type; - int length; - - /** lets initialize the key pointers **/ - for (key = 0; key < 13; key++) - (function_key[key]).str = NULL; - /** see if the user has a .clef file ***/ - HOME = getenv("HOME"); - sprintf(path, "%s/.clef", HOME); - if ((fd = open(path, O_RDONLY)) == -1) { - return; - } - else { - /*** If so, then get the key bindings **/ - while ((key = get_key(fd, &type))) { - length = get_str(fd, string); - switch (type) { - case 'D': - if (key == 12) { - fprintf(stderr, - "Clef Error: PF12 can only be of type E in .clef\n"); - fprintf(stderr, "Line will be ignored\n"); - type = -1; - } - else { - (function_key[key]).type = DELAYED; - } - break; - case 'F': - if (key == 12) { - fprintf(stderr, - "Clef Error: PF12 can only be of type E in .clef\n"); - fprintf(stderr, "Line will be ignored\n"); - type = -1; - } - else { - (function_key[key]).type = IMMEDIATE; - } - break; - case 'E': - if (key != 12) { - fprintf(stderr, - "Clef Error: PF12 can only be of type E in .clef\n"); - fprintf(stderr, "Line will be ignored\n"); - type = -1; - } - else { - (function_key[key]).type = SPECIAL; - } - break; - } - if (type != -1) { - (function_key[key]).str = - (char *) malloc(strlen(string) + 1); - sprintf((function_key[key]).str, "%s", string); - } - } - } - - /* - * Now set the editor function key - */ - set_editor_key(); -} - - -#define defof(c) ((c == 'F' || c == 'D' || c == 'E')?(1):(0)) - -int -get_key(int fd,char * ty) -{ - - /* - * Determines the key number being mapped, and whether it is immediate or - * delay. It reurns the key value, and modifies the parameter type - */ - char keynum[1024]; - int nr; - - nr = read(fd, keynum, 3); - if (nr != -1 && nr != 0) { - if (!defof(keynum[0])) { - return 0; - } - else { - *ty = keynum[0]; - keynum[3] = '\0'; - return (atoi(&keynum[1])); - } - } - else - return 0; -} - -int -get_str(int fd,char * string) -{ - /** Gets the key mapping being bound **/ - char c; - int count = 0; - char *trace = string; - - read(fd, &c, 1); - while (c == ' ') - read(fd, &c, 1); - while (c != '\n') { - count++; - *trace++ = c; - if (read(fd, &c, 1) == 0) - break; - } - *trace = '\0'; - return count; -} - -void -null_fnct(int sig) -{ - return; -} - -void -handle_function_key(int key,int chann) -{ - /** this procedure simply adds the string specified by the function key - to the buffer ****/ - int count, fd; - int amount = strlen(function_key[key].str); - int id; - int save_echo; - - /*** This procedure takes the character at in_buff[num_proc] and adds - it to the buffer. It first checks to see if we should be inserting - or overwriting, and then does the appropriate thing *******/ - - switch ((function_key[key]).type) { - case IMMEDIATE: - if (INS_MODE) { - forwardcopy(&buff[curr_pntr + amount], - &buff[curr_pntr], - buff_pntr - curr_pntr); - forwardflag_cpy(&buff_flag[curr_pntr + amount], - &buff_flag[curr_pntr], - buff_pntr - curr_pntr); - for (count = 0; count < amount; count++) { - buff[curr_pntr + count] = (function_key[key].str)[count]; - buff_flag[curr_pntr + count] = '1'; - } - ins_print(curr_pntr, amount + 1); - buff_pntr = buff_pntr + amount; - } - else { - for (count = 0; count < amount; count++) { - buff[curr_pntr + count] = (function_key[key].str)[count]; - buff_flag[curr_pntr + count] = '1'; - myputchar((function_key[key].str)[count]); - } - } - num_proc = num_proc + 6; - curr_pntr = curr_pntr + amount; - buff_pntr = buff_pntr + amount; - send_function_to_child(); - break; - case DELAYED: - if (INS_MODE) { - forwardcopy(&buff[curr_pntr + amount], - &buff[curr_pntr], - buff_pntr - curr_pntr); - forwardflag_cpy(&buff_flag[curr_pntr + amount], - &buff_flag[curr_pntr], - buff_pntr - curr_pntr); - for (count = 0; count < amount; count++) { - buff[curr_pntr + count] = (function_key[key].str)[count]; - buff_flag[curr_pntr + count] = '1'; - } - ins_print(curr_pntr, amount + 1); - buff_pntr = buff_pntr + amount; - } - else { - for (count = 0; count < amount; count++) { - buff[curr_pntr + count] = (function_key[key].str)[count]; - buff_flag[curr_pntr + count] = '1'; - myputchar((function_key[key].str)[count]); - } - } - num_proc = num_proc + 6; - curr_pntr = curr_pntr + amount; - buff_pntr = buff_pntr + amount; - fflush(stdout); - break; - case SPECIAL: - /* fprintf(stderr, "Here I am \n"); */ - if (access(editorfilename, F_OK) < 0) { - fd = open(editorfilename, O_RDWR | O_CREAT, 0666); - write(fd, buff, buff_pntr); - back_up(buff_pntr); - close(fd); - } - else { - if (buff_pntr > 0) { - fd = open(editorfilename, O_RDWR | O_TRUNC); - write(fd, buff, buff_pntr); - back_up(buff_pntr); - close(fd); - } - } -<> - switch (id = fork()) { - case -1: - perror("Special key"); - break; - case 0: - execlp((function_key[12]).str, - (function_key[12]).str, - editorfilename, NULL); - perror("Returned from exec"); - exit(0); - - } - while (wait((int *) 0) < 0); - /** now I should read that file and send all it stuff thru the - reader *****/ - fd = open(editorfilename, O_RDWR); - if (fd == -1) { - perror("Opening temp file"); - exit(-1); - } - num_proc += 6; - - /** reinitialize the buffer ***/ - init_flag(buff_flag, buff_pntr); - init_buff(buff, buff_pntr); - /** reinitialize my buffer pointers **/ - buff_pntr = curr_pntr = 0; - /** reset the ring pointer **/ - current = NULL; - save_echo = ECHOIT; - ECHOIT = 0; - while ((num_read = read(fd, in_buff, MAXLINE))) { - do_reading(); - } - close(fd); - break; - } - return; - -} -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/halloc.c b/src/lib/halloc.c new file mode 100644 index 00000000..aa9fe9dd --- /dev/null +++ b/src/lib/halloc.c @@ -0,0 +1,57 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" + +/* memory allocation used by HyperDoc and addfile */ + +#include +#include + +#include "halloc.H1" + + +/* allocate memory and bomb if none left (hyperTeX alloc) */ +char * +halloc(int bytes,char * msg) +{ + static char buf[200]; + char *result; + + result = (char *) malloc(bytes); + if (result == NULL) { + sprintf(buf, "Ran out of memory allocating %s.\b", msg); + exit(-1); + } + return result; +} diff --git a/src/lib/halloc.c.pamphlet b/src/lib/halloc.c.pamphlet deleted file mode 100644 index 037181d3..00000000 --- a/src/lib/halloc.c.pamphlet +++ /dev/null @@ -1,79 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib halloc.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" - -/* memory allocation used by HyperDoc and addfile */ - -#include -#include - -#include "halloc.H1" - - -/* allocate memory and bomb if none left (hyperTeX alloc) */ -char * -halloc(int bytes,char * msg) -{ - static char buf[200]; - char *result; - - result = (char *) malloc(bytes); - if (result == NULL) { - sprintf(buf, "Ran out of memory allocating %s.\b", msg); - exit(-1); - } - return result; -} -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/hash.c b/src/lib/hash.c new file mode 100644 index 00000000..b7a8a379 --- /dev/null +++ b/src/lib/hash.c @@ -0,0 +1,219 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + + +#include "axiom-c-macros.h" +#define _HASH_C +#include "debug.h" + +#include +#include +#include +#include "hash.h" + +#include "hash.H1" +#include "halloc.H1" + +/* initialize a hash table */ + +void +hash_init(HashTable *table, int size, EqualFunction equal, + HashcodeFunction hash_code) +{ + int i; + + table->table = + (HashEntry **) halloc(size * sizeof(HashEntry *), "HashEntry"); + for (i = 0; i < size; i++) + table->table[i] = NULL; + table->size = size; + table->equal = equal; + table->hash_code = hash_code; + table->num_entries = 0; +} + +void +free_hash(HashTable *table, FreeFunction free_fun) +{ + if (table) { + int i; + + for (i = 0; i < table->size; i++) { + HashEntry *e, *next; + + for (e = table->table[i]; e != NULL;) { + next = e->next; + (*free_fun) (e->data); + (*e).data=0; + free(e); + e = next; + } + } + free(table->table); + } +} + +/* insert an entry into a hash table */ + +void +hash_insert(HashTable *table, char *data, char *key) +{ + HashEntry *entry = (HashEntry *) halloc(sizeof(HashEntry), "HashEntry"); + int code; + + entry->data = data; + entry->key = key; + code = (*table->hash_code) (key, table->size) % table->size; +#ifdef DEBUG + fprintf(stderr, "Hash value = %d\n", code); +#endif + entry->next = table->table[code]; + table->table[code] = entry; + table->num_entries++; +} + +char * +hash_find(HashTable *table, char *key) +{ + HashEntry *entry; + int code = table->hash_code(key, table->size) % table->size; + + for (entry = table->table[code]; entry != NULL; entry = entry->next) + if ((*table->equal) (entry->key, key)) + return entry->data; + return NULL; +} + +char * +hash_replace(HashTable *table, char *data, char *key) +{ + HashEntry *entry; + int code = table->hash_code(key, table->size) % table->size; + + for (entry = table->table[code]; entry != NULL; entry = entry->next) + if ((*table->equal) (entry->key, key)) { + entry->data = data; + return entry->data; + } + return NULL; +} + +void +hash_delete(HashTable *table, char *key) +{ + HashEntry **entry; + int code = table->hash_code(key, table->size) % table->size; + + for (entry = &table->table[code]; *entry != NULL; entry = &((*entry)->next)) + if ((*table->equal) ((*entry)->key, key)) { + *entry = (*entry)->next; + table->num_entries--; + return; + } +} + +void +hash_map(HashTable *table, MappableFunction func) +{ + int i; + HashEntry *e; + + if (table == NULL) + return; + for (i = 0; i < table->size; i++) + for (e = table->table[i]; e != NULL; e = e->next) + (*func) (e->data); +} + +HashEntry * +hash_copy_entry(HashEntry *e) +{ + HashEntry *ne; + + if (e == NULL) + return e; + ne = (HashEntry *) halloc(sizeof(HashEntry), "HashEntry"); + ne->data = e->data; + ne->key = e->key; + ne->next = hash_copy_entry(e->next); + return ne; +} + +/* copy a hash table */ +HashTable * +hash_copy_table(HashTable *table) +{ + HashTable *nt = (HashTable *) halloc(sizeof(HashTable), "copy hash table"); + int i; + + nt->size = table->size; + nt->num_entries = table->num_entries; + nt->equal = table->equal; + nt->hash_code = table->hash_code; + nt->table = (HashEntry **) halloc(nt->size * sizeof(HashEntry *), + "copy table"); + for (i = 0; i < table->size; i++) + nt->table[i] = hash_copy_entry(table->table[i]); + return nt; +} + +/* hash code function for strings */ +int +string_hash(char *s, int size) +{ + int c = 0; + char *p =s; + + + while (*p) + c += *p++; + return c % size; +} + +/* test strings for equality */ + +int +string_equal(char *s1, char *s2) +{ + return (strcmp(s1, s2) == 0); +} + +/* make a fresh copy of the given string */ +char * +alloc_string(char *str) +{ + char * result; + result = halloc(strlen(str)+1,"String"); + strcpy(result,str); + return (result); +} diff --git a/src/lib/hash.c.pamphlet b/src/lib/hash.c.pamphlet deleted file mode 100644 index 44fed43a..00000000 --- a/src/lib/hash.c.pamphlet +++ /dev/null @@ -1,240 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{no title} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -#define _HASH_C -#include "debug.h" - -#include -#include -#include -#include "hash.h" - -#include "hash.H1" -#include "halloc.H1" - -/* initialize a hash table */ - -void -hash_init(HashTable *table, int size, EqualFunction equal, - HashcodeFunction hash_code) -{ - int i; - - table->table = - (HashEntry **) halloc(size * sizeof(HashEntry *), "HashEntry"); - for (i = 0; i < size; i++) - table->table[i] = NULL; - table->size = size; - table->equal = equal; - table->hash_code = hash_code; - table->num_entries = 0; -} - -void -free_hash(HashTable *table, FreeFunction free_fun) -{ - if (table) { - int i; - - for (i = 0; i < table->size; i++) { - HashEntry *e, *next; - - for (e = table->table[i]; e != NULL;) { - next = e->next; - (*free_fun) (e->data); - (*e).data=0; - free(e); - e = next; - } - } - free(table->table); - } -} - -/* insert an entry into a hash table */ - -void -hash_insert(HashTable *table, char *data, char *key) -{ - HashEntry *entry = (HashEntry *) halloc(sizeof(HashEntry), "HashEntry"); - int code; - - entry->data = data; - entry->key = key; - code = (*table->hash_code) (key, table->size) % table->size; -#ifdef DEBUG - fprintf(stderr, "Hash value = %d\n", code); -#endif - entry->next = table->table[code]; - table->table[code] = entry; - table->num_entries++; -} - -char * -hash_find(HashTable *table, char *key) -{ - HashEntry *entry; - int code = table->hash_code(key, table->size) % table->size; - - for (entry = table->table[code]; entry != NULL; entry = entry->next) - if ((*table->equal) (entry->key, key)) - return entry->data; - return NULL; -} - -char * -hash_replace(HashTable *table, char *data, char *key) -{ - HashEntry *entry; - int code = table->hash_code(key, table->size) % table->size; - - for (entry = table->table[code]; entry != NULL; entry = entry->next) - if ((*table->equal) (entry->key, key)) { - entry->data = data; - return entry->data; - } - return NULL; -} - -void -hash_delete(HashTable *table, char *key) -{ - HashEntry **entry; - int code = table->hash_code(key, table->size) % table->size; - - for (entry = &table->table[code]; *entry != NULL; entry = &((*entry)->next)) - if ((*table->equal) ((*entry)->key, key)) { - *entry = (*entry)->next; - table->num_entries--; - return; - } -} - -void -hash_map(HashTable *table, MappableFunction func) -{ - int i; - HashEntry *e; - - if (table == NULL) - return; - for (i = 0; i < table->size; i++) - for (e = table->table[i]; e != NULL; e = e->next) - (*func) (e->data); -} - -HashEntry * -hash_copy_entry(HashEntry *e) -{ - HashEntry *ne; - - if (e == NULL) - return e; - ne = (HashEntry *) halloc(sizeof(HashEntry), "HashEntry"); - ne->data = e->data; - ne->key = e->key; - ne->next = hash_copy_entry(e->next); - return ne; -} - -/* copy a hash table */ -HashTable * -hash_copy_table(HashTable *table) -{ - HashTable *nt = (HashTable *) halloc(sizeof(HashTable), "copy hash table"); - int i; - - nt->size = table->size; - nt->num_entries = table->num_entries; - nt->equal = table->equal; - nt->hash_code = table->hash_code; - nt->table = (HashEntry **) halloc(nt->size * sizeof(HashEntry *), - "copy table"); - for (i = 0; i < table->size; i++) - nt->table[i] = hash_copy_entry(table->table[i]); - return nt; -} - -/* hash code function for strings */ -int -string_hash(char *s, int size) -{ - int c = 0; - char *p =s; - - - while (*p) - c += *p++; - return c % size; -} - -/* test strings for equality */ - -int -string_equal(char *s1, char *s2) -{ - return (strcmp(s1, s2) == 0); -} - -/* make a fresh copy of the given string */ -char * -alloc_string(char *str) -{ - char * result; - result = halloc(strlen(str)+1,"String"); - strcpy(result,str); - return (result); -} -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/openpty.c b/src/lib/openpty.c new file mode 100644 index 00000000..5b99f2ad --- /dev/null +++ b/src/lib/openpty.c @@ -0,0 +1,192 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" +#include +#include +#include +#include +#include + +#if defined(SUN4OS5platform) || defined(HP10platform) +#include +#endif + + +#include "openpty.H1" + + +/* + * The main function is ptyopen. It simply opens up both sides of a + * pseudo-terminal. It uses and saves the pathnames for + * the devices which were actually opened. + * + * If it fails it simply exits the program. + * + * + * ptyopen(controller, server, controllerPath, serverPath) + * int *controller; The file descriptor for controller side of the pty + * int *server; The file descriptor for the server side + * char *controllerPath; actually , this is not used anywhere on return + and can be taken out of the call sequence + * char *serverPath; + * + * The path name vars should be declared of size 11 or more + */ + + +int +ptyopen(int *controller,int * server, char *controllerPath,char * serverPath) +{ +#if defined(SUNplatform) || defined (HP9platform) || defined(RTplatform) ||defined(AIX370platform) || defined(BSDplatform) + int looking = 1, i; + int oflag = O_RDWR; /* flag for opening the pty */ + + for (i = 0; looking && i < 1000; i++) { + makeNextPtyNames(controllerPath, serverPath); + if (access(controllerPath, 6) != 0) continue; + *controller = open(controllerPath, oflag, 0); + if (*controller >= 0) { + *server = open(serverPath, oflag, 0); + if (*server > 0) + looking = 0; + else + close(*controller); + } + } + if (looking) { + fprintf(stderr, "Couldn't find a free pty.\n"); + exit(-1); + } + return (*controller); +#endif +#if defined RIOSplatform + int fdm,fds; + char *slavename; + + /* open master */ + if ((fdm=open("/dev/ptc",O_RDWR))<0) + perror("ptyopen failed to open /dev/ptc"); + else { + /* get slave name */ + if((slavename = ttyname(fdm))==0) + perror("ptyopen failed to get the slave device name"); + /* open slave */ + if ((fds = open(slavename, O_RDWR)) < 0 ) + perror("ptyopen: Failed to open slave"); + strcpy(serverPath,slavename); + *controller=fdm; + *server=fds; + } + return(fdm); +#endif + +#if defined(SUN4OS5platform) ||defined(ALPHAplatform) || defined(HP10platform) || defined(LINUXplatform) || defined(MACOSXplatform) || defined(BSDplatform) +extern int grantpt(int); +extern int unlockpt(int); +extern char* ptsname(int); + int fdm,fds; + char *slavename; + + /* open master */ + if ((fdm = open("/dev/ptmx", O_RDWR)) < 0 ) + perror("ptyopen: Failed to open /dev/ptmx"); + else { + /* change permission ofslave */ + if (grantpt(fdm) < 0) + perror("ptyopen: Failed to grant access to slave device"); + /* unlock slave */ + if (unlockpt(fdm) < 0) + perror("ptyopen: Failed to unlock master/slave pair"); + /* get name of slave */ + if ((slavename = ptsname(fdm)) == NULL) + perror("ptyopen: Failed to get name of slave device"); + /* open slave */ + if ((fds = open(slavename, O_RDWR)) < 0 ) + perror("ptyopen: Failed to open slave"); + else { +#if defined(SUN4OS5platform) || defined(HP10platform) + /* push ptem */ + if (ioctl(fds, I_PUSH, "ptem") < 0) + perror("ptyopen: Failed to push ptem"); + /* push ldterm */ + if (ioctl(fds, I_PUSH, "ldterm") < 0) + perror("ptyopen: Failed to push idterm"); +#endif + strcpy(serverPath,slavename); + *controller=fdm; + *server=fds; + } + } + return(fdm); +#endif +#if defined SGIplatform + char *fds; + fds = _getpty(controller, O_RDWR|O_NDELAY, 0600, 0); + strcpy(serverPath,fds); + if (0 == serverPath) + return(-1); + if (0 > (*server = open(serverPath,O_RDWR))) { + (void) close(*controller); + return(-1); + } + return (*controller); + +#endif +} + + +void +makeNextPtyNames(char *cont,char * serv) +{ +#ifdef AIX370platform + static int channelNo = 0; + sprintf(cont, "/dev/ptyp%02x", channelNo); + sprintf(serv, "/dev/ttyp%02x", channelNo); + channelNo++; +#endif +#if defined(SUNplatform) || defined(HP9platform) || defined(LINUXplatform) || defined(MACOSXplatform) || defined(BSDplatform) + static int channelNo = 0; + static char group[] = "pqrstuvwxyzPQRST"; + static int groupNo = 0; + + sprintf(cont, "/dev/pty%c%x", group[groupNo], channelNo); + sprintf(serv, "/dev/tty%c%x", group[groupNo], channelNo); + channelNo++; /* try next */ + if (channelNo == 16) { /* move to new group */ + channelNo = 0; + groupNo++; + if (groupNo == 16) groupNo = 0; /* recycle */ + } +#endif +} diff --git a/src/lib/openpty.c.pamphlet b/src/lib/openpty.c.pamphlet deleted file mode 100644 index 20976367..00000000 --- a/src/lib/openpty.c.pamphlet +++ /dev/null @@ -1,226 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib openpty.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{MAC OSX and BSD platform changes} -Since we have no other information we are adding the [[MACOSXplatform]] variable -to the list everywhere we find [[LINUXplatform]]. This may not be correct but -we have no way to know yet. We have also added the [[BSDplatform]] variable. -MAC OSX is some variant of BSD. These should probably be merged but we -cannot yet prove that. -<>= -#if defined(SUN4OS5platform) ||defined(ALPHAplatform) || defined(HP10platform) || defined(LINUXplatform) || defined(MACOSXplatform) || defined(BSDplatform) -@ -<>= -#if defined(SUNplatform) || defined(HP9platform) || defined(LINUXplatform) || defined(MACOSXplatform) || defined(BSDplatform) -@ -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -#include -#include -#include -#include -#include - -#if defined(SUN4OS5platform) || defined(HP10platform) -#include -#endif - - -#include "openpty.H1" - - -/* - * The main function is ptyopen. It simply opens up both sides of a - * pseudo-terminal. It uses and saves the pathnames for - * the devices which were actually opened. - * - * If it fails it simply exits the program. - * - * - * ptyopen(controller, server, controllerPath, serverPath) - * int *controller; The file descriptor for controller side of the pty - * int *server; The file descriptor for the server side - * char *controllerPath; actually , this is not used anywhere on return - and can be taken out of the call sequence - * char *serverPath; - * - * The path name vars should be declared of size 11 or more - */ - - -int -ptyopen(int *controller,int * server, char *controllerPath,char * serverPath) -{ -#if defined(SUNplatform) || defined (HP9platform) || defined(RTplatform) ||defined(AIX370platform) || defined(BSDplatform) - int looking = 1, i; - int oflag = O_RDWR; /* flag for opening the pty */ - - for (i = 0; looking && i < 1000; i++) { - makeNextPtyNames(controllerPath, serverPath); - if (access(controllerPath, 6) != 0) continue; - *controller = open(controllerPath, oflag, 0); - if (*controller >= 0) { - *server = open(serverPath, oflag, 0); - if (*server > 0) - looking = 0; - else - close(*controller); - } - } - if (looking) { - fprintf(stderr, "Couldn't find a free pty.\n"); - exit(-1); - } - return (*controller); -#endif -#if defined RIOSplatform - int fdm,fds; - char *slavename; - - /* open master */ - if ((fdm=open("/dev/ptc",O_RDWR))<0) - perror("ptyopen failed to open /dev/ptc"); - else { - /* get slave name */ - if((slavename = ttyname(fdm))==0) - perror("ptyopen failed to get the slave device name"); - /* open slave */ - if ((fds = open(slavename, O_RDWR)) < 0 ) - perror("ptyopen: Failed to open slave"); - strcpy(serverPath,slavename); - *controller=fdm; - *server=fds; - } - return(fdm); -#endif - -<> -extern int grantpt(int); -extern int unlockpt(int); -extern char* ptsname(int); - int fdm,fds; - char *slavename; - - /* open master */ - if ((fdm = open("/dev/ptmx", O_RDWR)) < 0 ) - perror("ptyopen: Failed to open /dev/ptmx"); - else { - /* change permission ofslave */ - if (grantpt(fdm) < 0) - perror("ptyopen: Failed to grant access to slave device"); - /* unlock slave */ - if (unlockpt(fdm) < 0) - perror("ptyopen: Failed to unlock master/slave pair"); - /* get name of slave */ - if ((slavename = ptsname(fdm)) == NULL) - perror("ptyopen: Failed to get name of slave device"); - /* open slave */ - if ((fds = open(slavename, O_RDWR)) < 0 ) - perror("ptyopen: Failed to open slave"); - else { -#if defined(SUN4OS5platform) || defined(HP10platform) - /* push ptem */ - if (ioctl(fds, I_PUSH, "ptem") < 0) - perror("ptyopen: Failed to push ptem"); - /* push ldterm */ - if (ioctl(fds, I_PUSH, "ldterm") < 0) - perror("ptyopen: Failed to push idterm"); -#endif - strcpy(serverPath,slavename); - *controller=fdm; - *server=fds; - } - } - return(fdm); -#endif -#if defined SGIplatform - char *fds; - fds = _getpty(controller, O_RDWR|O_NDELAY, 0600, 0); - strcpy(serverPath,fds); - if (0 == serverPath) - return(-1); - if (0 > (*server = open(serverPath,O_RDWR))) { - (void) close(*controller); - return(-1); - } - return (*controller); - -#endif -} - - -void -makeNextPtyNames(char *cont,char * serv) -{ -#ifdef AIX370platform - static int channelNo = 0; - sprintf(cont, "/dev/ptyp%02x", channelNo); - sprintf(serv, "/dev/ttyp%02x", channelNo); - channelNo++; -#endif -<> - static int channelNo = 0; - static char group[] = "pqrstuvwxyzPQRST"; - static int groupNo = 0; - - sprintf(cont, "/dev/pty%c%x", group[groupNo], channelNo); - sprintf(serv, "/dev/tty%c%x", group[groupNo], channelNo); - channelNo++; /* try next */ - if (channelNo == 16) { /* move to new group */ - channelNo = 0; - groupNo++; - if (groupNo == 16) groupNo = 0; /* recycle */ - } -#endif -} -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/pixmap.c b/src/lib/pixmap.c new file mode 100644 index 00000000..05b06c25 --- /dev/null +++ b/src/lib/pixmap.c @@ -0,0 +1,321 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" + +#include +#include +#include +#include +#include +#include + +#define yes 1 +#define no 0 + + + +#include "spadcolors.h" + +#include "pixmap.H1" +#include "halloc.H1" +#include "spadcolors.H1" + + + +/* returns true if the file exists */ + +int +file_exists(char *file) +{ + FILE *f; + + if ((f = fopen(file, "r")) != NULL) { + fclose(f); + return 1; + } + return 0; +} + +FILE * +zzopen(char *file,char * mode) +{ + char com[512], zfile[512]; + + if (file_exists(file)) + return fopen(file, mode); + sprintf(zfile, "%s.Z", file); + if (file_exists(zfile)) { + sprintf(com, "gunzip -c %s.Z 2>/dev/null", file); + return popen(com, mode); + } + return NULL; +} +#ifdef OLD + +/******************************************************************* + KF 6/14/90 + write_pixmap_file(display, filename, pm, width, height) + and + write_pixmap_file_xy(display, filename, pm, x, y, width, height) + has been merged into one function. + + INPUT: display dsp, screen s, file name fn to write the file in, + window id wid where pixmap is, + upper left corner x, y of original pixmap, + width and height of pixmap + OUTPUT: binary file with data + PURPOSE: write_pixmap_file gets the image structure of the input + pixmap, convert the image data with the permutation color + vector, writes the image structure out to filename. + + Note that writing out a Z pixmap is 8x faster than XY pixmap. + This is because XY writes out each pixel value per plane, thus + number of bits; Z writes out each pixel, or 8 bits at a time. + + The XY format may have been chosen for a reason -- I don't know. + +********************************************************************/ +void +write_pixmap_file(Display *dsp, int scr, char *fn, + Window wid, int x, int y, int width,int height) +{ + XImage *xi; + FILE *file; + int *permVector; + int num; + int num_colors; + + /* get color map and permutation vector */ + if ((num_colors = makePermVector(dsp, scr,(unsigned long **)&permVector)) < 0) { + printf("num_colors < 0!!\n"); + exit(-1); + } + + /* reads image structure in ZPixmap format */ + xi = XGetImage(dsp, wid, x, y, width, height, AllPlanes, ZPixmap); + file = fopen(fn, "wb"); + if (file == NULL) { + perror("opening pixmap file for write"); + exit(-1); + } + +#define PUTW(a,b) putw(htonl(a),b) + + + PUTW(xi->width, file); + PUTW(xi->height, file); + PUTW(xi->xoffset, file); + PUTW(xi->format, file); + PUTW(xi->byte_order, file); + PUTW(xi->bitmap_unit, file); + PUTW(xi->bitmap_bit_order, file); + PUTW(xi->bitmap_pad, file); + PUTW(xi->depth, file); + PUTW(xi->bytes_per_line, file); + PUTW(xi->bits_per_pixel, file); + PUTW(xi->red_mask, file); + PUTW(xi->green_mask, file); + PUTW(xi->blue_mask, file); + + num = xi->bytes_per_line * height; /* total number of pixels in pixmap */ + + /* store value from permutation */ + { + int ii, jj; + + for (ii = 0; ii < width; ii++) + for (jj = 0; jj < height; jj++) { + XPutPixel(xi, ii, jj, permVector[(int) XGetPixel(xi, ii, jj)]); + } + } + fwrite(xi->data, 1, num, file); + fclose(file); +} + +/******************************************************************* + KF 6/14/90 + + INPUT: display, screen, filename to read the pixmap data from, + OUTPUT: ximage structure xi, width and height of pixmap + PURPOSE: read_pixmap_file reads an Ximage data structure from + the input file. + This routine can handle pixmaps of both XYPixmap and + ZPixmap. If a pixmap has ZPixmap format, then the image + data, read in as spadColor index, is converted to the + pixel value using spadColor. + + Note that reading in Z format takes less space and time too. + +********************************************************************/ +int +read_pixmap_file(Display *display, int screen, char *filename, + XImage **xi, int *width, int *height) +{ + FILE *file; + int wi, h, num, num_colors, read_this_time, offset; + Colormap cmap; + int ts; + unsigned long *spadColors; + + /* colormap is necessary to call makeColors */ + cmap = DefaultColormap(display, screen); + if ((num_colors = makeColors(display, screen, &cmap, &spadColors, &ts)) < 0) { + return(-1); + } + file = zzopen(filename, "r"); + if (file == NULL) { + printf("couldn't open %s\n", filename); + return BitmapOpenFailed; + } +#define GETW(f) ntohl(getw(f)) + *width = wi = GETW(file); + *height = h = GETW(file); + (*xi) = XCreateImage(display, DefaultVisual(display, screen), + DisplayPlanes(display, screen), + ZPixmap, 0, NULL, wi, h, 16, 0); /* handles both XY & Z */ + if ((*xi) == NULL) { + fprintf(stderr, "Unable to create image\n"); + return(-1); + } + (*xi)->width = wi; + (*xi)->height = h; + (*xi)->xoffset = GETW(file); + (*xi)->format = GETW(file); + (*xi)->byte_order = GETW(file); + (*xi)->bitmap_unit = GETW(file); + (*xi)->bitmap_bit_order = GETW(file); + (*xi)->bitmap_pad = GETW(file); + (*xi)->depth = GETW(file); + (*xi)->bytes_per_line = GETW(file); + (*xi)->bits_per_pixel = GETW(file); + (*xi)->red_mask = GETW(file); + (*xi)->green_mask = GETW(file); + (*xi)->blue_mask = GETW(file); + + /* program will bomb if XYPixmap is not allocated enough space */ + if ((*xi)->format == XYPixmap) { + /* printf("picture is in XYPixmap format.\n"); */ + num = (*xi)->bytes_per_line * h * (*xi)->depth; + } + else /* ZPixmap */ + num = (*xi)->bytes_per_line * h; + (*xi)->data = (void*)halloc(num, "Ximage data"); + + offset = 0; + while (offset < num) { + read_this_time = fread(((*xi)->data + offset), 1, num - offset, file); + offset = offset + read_this_time; + } + fclose(file); + + /* + * pixmap data in ZPixmap format are spadColor indices; pixmap data in + * XYPixmap format are pixel values + */ + if ((*xi)->format == ZPixmap) { + + int ii, jj; + + for (ii = 0; ii < wi; ii++) + for (jj = 0; jj < h; jj++) { + XPutPixel(*xi, ii, jj, spadColors[(int) XGetPixel(*xi, ii, jj)]); + } + + + } + + return 0; +} + + +#else /*OLD*/ + + +#include "xpm.h" + +int +read_pixmap_file(Display *display, int screen, char *filename, + XImage **xi, int *width, int *height) +{ + XpmAttributes attr; + XImage *xireturn; + int status; + + attr.valuemask = 0; + + attr.bitmap_format=ZPixmap; /* instead of XYPixmap */ + attr.valuemask |= XpmBitmapFormat; + attr.valuemask |= XpmSize; /* we want feedback on width,height */ + attr.valuemask |= XpmCharsPerPixel; /* and cpp */ + attr.valuemask |= XpmReturnPixels; /* and pixels, npixels */ + attr.valuemask |= XpmReturnAllocPixels; /* and alloc_pixels, nalloc_pixels */ + attr.exactColors = False; + attr.valuemask |= XpmExactColors; /* we don't want exact colors*/ + attr.closeness = 30000; + attr.valuemask |= XpmCloseness; /* we specify closeness*/ + attr.alloc_close_colors = False; + attr.valuemask |= XpmAllocCloseColors; /* we don't allocate close colors*/ + + + status=XpmReadFileToImage(display,filename,xi,&xireturn, &attr ); + *width= (*xi)->width; + *height=(*xi)->height; +#ifdef DEBUG + fprintf(stderr,"image file:%s\n",filename); + fprintf(stderr,"\twidth:%d\theight:%d\tcpp:%d\n",attr.width,attr.height,attr.cpp); + fprintf(stderr,"\tused/alloc'ed color pixels:%d/%d\n",attr.npixels,attr.nalloc_pixels); +#endif + return 0; +} + + +void +write_pixmap_file(Display *dsp, int scr, char *fn, + Window wid, int x, int y, int width,int height) +{ + XImage *xi; + int status; + + /* reads image structure in ZPixmap format */ + xi = XGetImage(dsp, wid, x, y, width, height, AllPlanes, ZPixmap); + if (xi==0) return ; + status=XpmWriteFileFromImage(dsp,fn,xi,0,0); + +} + + +#endif + + + diff --git a/src/lib/pixmap.c.pamphlet b/src/lib/pixmap.c.pamphlet deleted file mode 100644 index 509e1ea3..00000000 --- a/src/lib/pixmap.c.pamphlet +++ /dev/null @@ -1,352 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib pixmap.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{MAC OSX zopen redefinition} -On the [[MAC OSX]] platform they defined [[zopen]]. Since the function -is only used in this file we simply rename it to [[zzopen]]. -<>= -FILE * -zzopen(char *file,char * mode) -@ -<>= - file = zzopen(filename, "r"); -@ -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" - -#include -#include -#include -#include -#include -#include - -#define yes 1 -#define no 0 - - - -#include "spadcolors.h" - -#include "pixmap.H1" -#include "halloc.H1" -#include "spadcolors.H1" - - - -/* returns true if the file exists */ - -int -file_exists(char *file) -{ - FILE *f; - - if ((f = fopen(file, "r")) != NULL) { - fclose(f); - return 1; - } - return 0; -} - -<> -{ - char com[512], zfile[512]; - - if (file_exists(file)) - return fopen(file, mode); - sprintf(zfile, "%s.Z", file); - if (file_exists(zfile)) { - sprintf(com, "gunzip -c %s.Z 2>/dev/null", file); - return popen(com, mode); - } - return NULL; -} -#ifdef OLD - -/******************************************************************* - KF 6/14/90 - write_pixmap_file(display, filename, pm, width, height) - and - write_pixmap_file_xy(display, filename, pm, x, y, width, height) - has been merged into one function. - - INPUT: display dsp, screen s, file name fn to write the file in, - window id wid where pixmap is, - upper left corner x, y of original pixmap, - width and height of pixmap - OUTPUT: binary file with data - PURPOSE: write_pixmap_file gets the image structure of the input - pixmap, convert the image data with the permutation color - vector, writes the image structure out to filename. - - Note that writing out a Z pixmap is 8x faster than XY pixmap. - This is because XY writes out each pixel value per plane, thus - number of bits; Z writes out each pixel, or 8 bits at a time. - - The XY format may have been chosen for a reason -- I don't know. - -********************************************************************/ -void -write_pixmap_file(Display *dsp, int scr, char *fn, - Window wid, int x, int y, int width,int height) -{ - XImage *xi; - FILE *file; - int *permVector; - int num; - int num_colors; - - /* get color map and permutation vector */ - if ((num_colors = makePermVector(dsp, scr,(unsigned long **)&permVector)) < 0) { - printf("num_colors < 0!!\n"); - exit(-1); - } - - /* reads image structure in ZPixmap format */ - xi = XGetImage(dsp, wid, x, y, width, height, AllPlanes, ZPixmap); - file = fopen(fn, "wb"); - if (file == NULL) { - perror("opening pixmap file for write"); - exit(-1); - } - -#define PUTW(a,b) putw(htonl(a),b) - - - PUTW(xi->width, file); - PUTW(xi->height, file); - PUTW(xi->xoffset, file); - PUTW(xi->format, file); - PUTW(xi->byte_order, file); - PUTW(xi->bitmap_unit, file); - PUTW(xi->bitmap_bit_order, file); - PUTW(xi->bitmap_pad, file); - PUTW(xi->depth, file); - PUTW(xi->bytes_per_line, file); - PUTW(xi->bits_per_pixel, file); - PUTW(xi->red_mask, file); - PUTW(xi->green_mask, file); - PUTW(xi->blue_mask, file); - - num = xi->bytes_per_line * height; /* total number of pixels in pixmap */ - - /* store value from permutation */ - { - int ii, jj; - - for (ii = 0; ii < width; ii++) - for (jj = 0; jj < height; jj++) { - XPutPixel(xi, ii, jj, permVector[(int) XGetPixel(xi, ii, jj)]); - } - } - fwrite(xi->data, 1, num, file); - fclose(file); -} - -/******************************************************************* - KF 6/14/90 - - INPUT: display, screen, filename to read the pixmap data from, - OUTPUT: ximage structure xi, width and height of pixmap - PURPOSE: read_pixmap_file reads an Ximage data structure from - the input file. - This routine can handle pixmaps of both XYPixmap and - ZPixmap. If a pixmap has ZPixmap format, then the image - data, read in as spadColor index, is converted to the - pixel value using spadColor. - - Note that reading in Z format takes less space and time too. - -********************************************************************/ -int -read_pixmap_file(Display *display, int screen, char *filename, - XImage **xi, int *width, int *height) -{ - FILE *file; - int wi, h, num, num_colors, read_this_time, offset; - Colormap cmap; - int ts; - unsigned long *spadColors; - - /* colormap is necessary to call makeColors */ - cmap = DefaultColormap(display, screen); - if ((num_colors = makeColors(display, screen, &cmap, &spadColors, &ts)) < 0) { - return(-1); - } -<> - if (file == NULL) { - printf("couldn't open %s\n", filename); - return BitmapOpenFailed; - } -#define GETW(f) ntohl(getw(f)) - *width = wi = GETW(file); - *height = h = GETW(file); - (*xi) = XCreateImage(display, DefaultVisual(display, screen), - DisplayPlanes(display, screen), - ZPixmap, 0, NULL, wi, h, 16, 0); /* handles both XY & Z */ - if ((*xi) == NULL) { - fprintf(stderr, "Unable to create image\n"); - return(-1); - } - (*xi)->width = wi; - (*xi)->height = h; - (*xi)->xoffset = GETW(file); - (*xi)->format = GETW(file); - (*xi)->byte_order = GETW(file); - (*xi)->bitmap_unit = GETW(file); - (*xi)->bitmap_bit_order = GETW(file); - (*xi)->bitmap_pad = GETW(file); - (*xi)->depth = GETW(file); - (*xi)->bytes_per_line = GETW(file); - (*xi)->bits_per_pixel = GETW(file); - (*xi)->red_mask = GETW(file); - (*xi)->green_mask = GETW(file); - (*xi)->blue_mask = GETW(file); - - /* program will bomb if XYPixmap is not allocated enough space */ - if ((*xi)->format == XYPixmap) { - /* printf("picture is in XYPixmap format.\n"); */ - num = (*xi)->bytes_per_line * h * (*xi)->depth; - } - else /* ZPixmap */ - num = (*xi)->bytes_per_line * h; - (*xi)->data = (void*)halloc(num, "Ximage data"); - - offset = 0; - while (offset < num) { - read_this_time = fread(((*xi)->data + offset), 1, num - offset, file); - offset = offset + read_this_time; - } - fclose(file); - - /* - * pixmap data in ZPixmap format are spadColor indices; pixmap data in - * XYPixmap format are pixel values - */ - if ((*xi)->format == ZPixmap) { - - int ii, jj; - - for (ii = 0; ii < wi; ii++) - for (jj = 0; jj < h; jj++) { - XPutPixel(*xi, ii, jj, spadColors[(int) XGetPixel(*xi, ii, jj)]); - } - - - } - - return 0; -} - - -#else /*OLD*/ - - -#include "xpm.h" - -int -read_pixmap_file(Display *display, int screen, char *filename, - XImage **xi, int *width, int *height) -{ - XpmAttributes attr; - XImage *xireturn; - int status; - - attr.valuemask = 0; - - attr.bitmap_format=ZPixmap; /* instead of XYPixmap */ - attr.valuemask |= XpmBitmapFormat; - attr.valuemask |= XpmSize; /* we want feedback on width,height */ - attr.valuemask |= XpmCharsPerPixel; /* and cpp */ - attr.valuemask |= XpmReturnPixels; /* and pixels, npixels */ - attr.valuemask |= XpmReturnAllocPixels; /* and alloc_pixels, nalloc_pixels */ - attr.exactColors = False; - attr.valuemask |= XpmExactColors; /* we don't want exact colors*/ - attr.closeness = 30000; - attr.valuemask |= XpmCloseness; /* we specify closeness*/ - attr.alloc_close_colors = False; - attr.valuemask |= XpmAllocCloseColors; /* we don't allocate close colors*/ - - - status=XpmReadFileToImage(display,filename,xi,&xireturn, &attr ); - *width= (*xi)->width; - *height=(*xi)->height; -#ifdef DEBUG - fprintf(stderr,"image file:%s\n",filename); - fprintf(stderr,"\twidth:%d\theight:%d\tcpp:%d\n",attr.width,attr.height,attr.cpp); - fprintf(stderr,"\tused/alloc'ed color pixels:%d/%d\n",attr.npixels,attr.nalloc_pixels); -#endif - return 0; -} - - -void -write_pixmap_file(Display *dsp, int scr, char *fn, - Window wid, int x, int y, int width,int height) -{ - XImage *xi; - int status; - - /* reads image structure in ZPixmap format */ - xi = XGetImage(dsp, wid, x, y, width, height, AllPlanes, ZPixmap); - if (xi==0) return ; - status=XpmWriteFileFromImage(dsp,fn,xi,0,0); - -} - - -#endif - - - -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/prt.c b/src/lib/prt.c new file mode 100644 index 00000000..4138bc50 --- /dev/null +++ b/src/lib/prt.c @@ -0,0 +1,407 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" +#include +#include +#include +#include "edible.h" + +#include "prt.H1" +#include "edin.H1" + +void +myputchar(char c) +{ + if (ECHOIT) + putchar(c); + return; +} + +void +clear_buff(void) +{ + int count; + + /*** called when spadbuf gives me a line incase there is something already + on the line ****/ + if (buff_pntr > 0) { + /*** backup to the beginning of the line ***/ + for (count = curr_pntr; count > 0; count--) + myputchar(_BKSPC); + /** blank over the line ***/ + for (count = 0; count < buff_pntr; count++) { + myputchar(_BLANK); + } + /** back up again ***/ + for (count = buff_pntr; count > 0; count--) + myputchar(_BKSPC); + init_buff(buff, buff_pntr); + init_flag(buff_flag, buff_pntr); + curr_pntr = buff_pntr = 0; + } +} + + +void +move_end(void) +{ + + /** Moves cursor to the end of the line ***/ + if (curr_pntr == buff_pntr) { + putchar(_BELL); + } + else { + for (; curr_pntr < buff_pntr;) { + myputchar(buff[curr_pntr++]); + } + } + fflush(stdout); +} + +void +move_home(void) +{ + + /*** Moves the cursor to the front of the line ***/ + if (curr_pntr > 0) { + for (; curr_pntr > 0;) { + myputchar(_BKSPC); + curr_pntr--; + } + } + else { + putchar(_BELL); + } + fflush(stdout); + +} + +void +move_fore_word(void) +{ + /** move the cursor to the next blank space **/ + if (curr_pntr != buff_pntr) { + myputchar(buff[curr_pntr]); + curr_pntr++; + while (curr_pntr < buff_pntr && buff[curr_pntr] != ' ') { + myputchar(buff[curr_pntr]); + curr_pntr++; + } + } + else + putchar(_BELL); + fflush(stdout); + return; +} + +void +move_back_word(void) +{ + /*** moves the cursor to the last blank space ***/ + if (curr_pntr > 0) { + myputchar(_BKSPC); + curr_pntr--; + while (curr_pntr > 0 && buff[curr_pntr - 1] != ' ') { + myputchar(_BKSPC); + curr_pntr--; + } + + } + else + putchar(_BELL); + fflush(stdout); + return; +} + +void +delete_current_char(void) +{ + /** deletes the char currently above the current_pntr, if it can be **/ + if (curr_pntr != buff_pntr) { + if (buff_flag[curr_pntr] == 1 || buff_flag[curr_pntr] == 0) { + myputchar(_BLANK); + myputchar(_BKSPC); + strcpy(&buff[curr_pntr], + &buff[curr_pntr + 1]); + flagcpy(&buff_flag[curr_pntr], + &buff_flag[curr_pntr + 1]); + buff_pntr--; + del_print(curr_pntr, 1); + } + else { + /** lets delete two of the little buggers **/ + myputchar(_BLANK); + myputchar(_BLANK); + myputchar(_BKSPC); + myputchar(_BKSPC); + strcpy(&buff[curr_pntr], + &buff[curr_pntr + 2]); + flagcpy(&buff_flag[curr_pntr], + &buff_flag[curr_pntr + 2]); + buff_pntr -= 2; + del_print(curr_pntr, 2); + } + } + else { + putchar(_BELL); + fflush(stdout); + } + num_proc = num_proc + 3; +} + +void +delete_to_end_of_line(void) +{ + int count; + + /*** deletes from the curr_pntr to the end of line ***/ + + if (curr_pntr == buff_pntr) + return; /** There is nothing to do **/ + + /** blank over the end of the line ***/ + for (count = curr_pntr; count < buff_pntr; count++) { + myputchar(_BLANK); + } + /** back up again ***/ + for (count = buff_pntr; count > curr_pntr; count--) + myputchar(_BKSPC); + + buff_pntr = curr_pntr; + fflush(stdout); + return; + +} + +void +delete_line(void) +{ + int count; + + /*** deletes the entire line *****/ + + if (buff_pntr == 0) + return; /** There is nothing to do **/ + + /** first I have to back up to the beginning of the line ****/ + for (count = curr_pntr; count > 0; count--) + myputchar(_BKSPC); + + /** blank over the end of the line ***/ + for (count = 0; count < buff_pntr; count++) { + myputchar(_BLANK); + } + /** back up again ***/ + for (count = buff_pntr; count > 0; count--) + myputchar(_BKSPC); + + /* Also clear the buffer */ + init_buff(buff, buff_pntr); + init_flag(buff_flag, buff_pntr); + buff_pntr = curr_pntr = 0; + + fflush(stdout); + return; + +} + +void +printbuff(int start,int num) +{ + int trace; + + for (trace = start; trace < start + num; trace++) + if (buff[trace] != '\0') + myputchar(buff[trace]); + fflush(stdout); +} + +void +del_print(int start, int num) +{ + int count; + + /*** move the rest of the string ***/ + for (count = start; count < buff_pntr; count++) { + myputchar(buff[count]); + } + /** now blank out the number of chars we are supposed to ***/ + for (count = 0; count < num; count++) + myputchar(_BLANK); + /*** Now back up ***/ + for (count = buff_pntr + num; count > start; count--) + myputchar(_BKSPC); + fflush(stdout); +} + + +void +ins_print(int start,int num) +{ + int count; + + /** write the rest of the word ***/ + for (count = start; count < buff_pntr + num; count++) { + myputchar(buff[count]); + } + /** now back up to where we should be ***/ + for (count = buff_pntr; count > start; count--) + myputchar(_BKSPC); + fflush(stdout); +} + +void +reprint(int start) +{ + /** simply reprints a single character **/ + if (buff[start] == '\0') + myputchar(_BLANK); + else + myputchar(buff[start]); + myputchar(_BKSPC); + fflush(stdout); + return; +} + +void +back_up(int num_chars) +{ + int cnt; + + for (cnt = 0; cnt < num_chars; cnt++) + myputchar(_BKSPC); + for (cnt = 0; cnt < num_chars; cnt++) + myputchar(_BLANK); + for (cnt = 0; cnt < num_chars; cnt++) + myputchar(_BKSPC); + fflush(stdout); + +} + +void +back_it_up(int num_chars) +{ + int cnt; + + for (cnt = 0; cnt < num_chars; cnt++) + myputchar(_BKSPC); + fflush(stdout); +} + + +void +print_whole_buff(void) +{ + int trace; + + for (trace = 0; trace < buff_pntr; trace++) + if (buff[trace] != '\0') + myputchar(buff[trace]); + fflush(stdout); +} + +void +move_ahead(void) +{ + /*** simply moves the pointer ahead a single word ***/ + if (curr_pntr == buff_pntr) { + putchar(_BELL); + } + else { + if (buff_flag[curr_pntr] == 2) { + myputchar(buff[curr_pntr++]); + } + myputchar(buff[curr_pntr++]); + } + fflush(stdout); +} + +void +move_back(void) +{ + /** simply moves the cursor back one position **/ + if (curr_pntr == 0) { + putchar(_BELL); + } + else { + if (!buff_flag[curr_pntr - 1]) { + myputchar(_BKSPC); + curr_pntr--; + } + myputchar(_BKSPC); + curr_pntr--; + } + fflush(stdout); +} + +void +back_over_current_char(void) +{ + /*** simply backs over the character behind the cursor ***/ + if (curr_pntr == 0) { + putchar(_BELL); + } + else { + if (!buff_flag[curr_pntr - 1]) { + myputchar(_BKSPC); + myputchar(_BKSPC); + myputchar(_BLANK); + myputchar(_BLANK); + myputchar(_BKSPC); + myputchar(_BKSPC); + strcpy(&buff[curr_pntr - 2], + &buff[curr_pntr]); + flagcpy(&buff_flag[curr_pntr - 2], + &buff_flag[curr_pntr]); + buff_pntr -= 2; + curr_pntr -= 2; + del_print(curr_pntr, 2); + } + else { + myputchar(_BKSPC); + myputchar(_BLANK); + myputchar(_BKSPC); + strcpy(&buff[curr_pntr - 1], + &buff[curr_pntr]); + flagcpy(&buff_flag[curr_pntr - 1], + &buff_flag[curr_pntr]); + curr_pntr--; + buff_pntr--; + del_print(curr_pntr, 1); + } + } + fflush(stdout); + return; +} + diff --git a/src/lib/prt.c.pamphlet b/src/lib/prt.c.pamphlet deleted file mode 100644 index 7491c9fb..00000000 --- a/src/lib/prt.c.pamphlet +++ /dev/null @@ -1,429 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib prt.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -#include -#include -#include -#include "edible.h" - -#include "prt.H1" -#include "edin.H1" - -void -myputchar(char c) -{ - if (ECHOIT) - putchar(c); - return; -} - -void -clear_buff(void) -{ - int count; - - /*** called when spadbuf gives me a line incase there is something already - on the line ****/ - if (buff_pntr > 0) { - /*** backup to the beginning of the line ***/ - for (count = curr_pntr; count > 0; count--) - myputchar(_BKSPC); - /** blank over the line ***/ - for (count = 0; count < buff_pntr; count++) { - myputchar(_BLANK); - } - /** back up again ***/ - for (count = buff_pntr; count > 0; count--) - myputchar(_BKSPC); - init_buff(buff, buff_pntr); - init_flag(buff_flag, buff_pntr); - curr_pntr = buff_pntr = 0; - } -} - - -void -move_end(void) -{ - - /** Moves cursor to the end of the line ***/ - if (curr_pntr == buff_pntr) { - putchar(_BELL); - } - else { - for (; curr_pntr < buff_pntr;) { - myputchar(buff[curr_pntr++]); - } - } - fflush(stdout); -} - -void -move_home(void) -{ - - /*** Moves the cursor to the front of the line ***/ - if (curr_pntr > 0) { - for (; curr_pntr > 0;) { - myputchar(_BKSPC); - curr_pntr--; - } - } - else { - putchar(_BELL); - } - fflush(stdout); - -} - -void -move_fore_word(void) -{ - /** move the cursor to the next blank space **/ - if (curr_pntr != buff_pntr) { - myputchar(buff[curr_pntr]); - curr_pntr++; - while (curr_pntr < buff_pntr && buff[curr_pntr] != ' ') { - myputchar(buff[curr_pntr]); - curr_pntr++; - } - } - else - putchar(_BELL); - fflush(stdout); - return; -} - -void -move_back_word(void) -{ - /*** moves the cursor to the last blank space ***/ - if (curr_pntr > 0) { - myputchar(_BKSPC); - curr_pntr--; - while (curr_pntr > 0 && buff[curr_pntr - 1] != ' ') { - myputchar(_BKSPC); - curr_pntr--; - } - - } - else - putchar(_BELL); - fflush(stdout); - return; -} - -void -delete_current_char(void) -{ - /** deletes the char currently above the current_pntr, if it can be **/ - if (curr_pntr != buff_pntr) { - if (buff_flag[curr_pntr] == 1 || buff_flag[curr_pntr] == 0) { - myputchar(_BLANK); - myputchar(_BKSPC); - strcpy(&buff[curr_pntr], - &buff[curr_pntr + 1]); - flagcpy(&buff_flag[curr_pntr], - &buff_flag[curr_pntr + 1]); - buff_pntr--; - del_print(curr_pntr, 1); - } - else { - /** lets delete two of the little buggers **/ - myputchar(_BLANK); - myputchar(_BLANK); - myputchar(_BKSPC); - myputchar(_BKSPC); - strcpy(&buff[curr_pntr], - &buff[curr_pntr + 2]); - flagcpy(&buff_flag[curr_pntr], - &buff_flag[curr_pntr + 2]); - buff_pntr -= 2; - del_print(curr_pntr, 2); - } - } - else { - putchar(_BELL); - fflush(stdout); - } - num_proc = num_proc + 3; -} - -void -delete_to_end_of_line(void) -{ - int count; - - /*** deletes from the curr_pntr to the end of line ***/ - - if (curr_pntr == buff_pntr) - return; /** There is nothing to do **/ - - /** blank over the end of the line ***/ - for (count = curr_pntr; count < buff_pntr; count++) { - myputchar(_BLANK); - } - /** back up again ***/ - for (count = buff_pntr; count > curr_pntr; count--) - myputchar(_BKSPC); - - buff_pntr = curr_pntr; - fflush(stdout); - return; - -} - -void -delete_line(void) -{ - int count; - - /*** deletes the entire line *****/ - - if (buff_pntr == 0) - return; /** There is nothing to do **/ - - /** first I have to back up to the beginning of the line ****/ - for (count = curr_pntr; count > 0; count--) - myputchar(_BKSPC); - - /** blank over the end of the line ***/ - for (count = 0; count < buff_pntr; count++) { - myputchar(_BLANK); - } - /** back up again ***/ - for (count = buff_pntr; count > 0; count--) - myputchar(_BKSPC); - - /* Also clear the buffer */ - init_buff(buff, buff_pntr); - init_flag(buff_flag, buff_pntr); - buff_pntr = curr_pntr = 0; - - fflush(stdout); - return; - -} - -void -printbuff(int start,int num) -{ - int trace; - - for (trace = start; trace < start + num; trace++) - if (buff[trace] != '\0') - myputchar(buff[trace]); - fflush(stdout); -} - -void -del_print(int start, int num) -{ - int count; - - /*** move the rest of the string ***/ - for (count = start; count < buff_pntr; count++) { - myputchar(buff[count]); - } - /** now blank out the number of chars we are supposed to ***/ - for (count = 0; count < num; count++) - myputchar(_BLANK); - /*** Now back up ***/ - for (count = buff_pntr + num; count > start; count--) - myputchar(_BKSPC); - fflush(stdout); -} - - -void -ins_print(int start,int num) -{ - int count; - - /** write the rest of the word ***/ - for (count = start; count < buff_pntr + num; count++) { - myputchar(buff[count]); - } - /** now back up to where we should be ***/ - for (count = buff_pntr; count > start; count--) - myputchar(_BKSPC); - fflush(stdout); -} - -void -reprint(int start) -{ - /** simply reprints a single character **/ - if (buff[start] == '\0') - myputchar(_BLANK); - else - myputchar(buff[start]); - myputchar(_BKSPC); - fflush(stdout); - return; -} - -void -back_up(int num_chars) -{ - int cnt; - - for (cnt = 0; cnt < num_chars; cnt++) - myputchar(_BKSPC); - for (cnt = 0; cnt < num_chars; cnt++) - myputchar(_BLANK); - for (cnt = 0; cnt < num_chars; cnt++) - myputchar(_BKSPC); - fflush(stdout); - -} - -void -back_it_up(int num_chars) -{ - int cnt; - - for (cnt = 0; cnt < num_chars; cnt++) - myputchar(_BKSPC); - fflush(stdout); -} - - -void -print_whole_buff(void) -{ - int trace; - - for (trace = 0; trace < buff_pntr; trace++) - if (buff[trace] != '\0') - myputchar(buff[trace]); - fflush(stdout); -} - -void -move_ahead(void) -{ - /*** simply moves the pointer ahead a single word ***/ - if (curr_pntr == buff_pntr) { - putchar(_BELL); - } - else { - if (buff_flag[curr_pntr] == 2) { - myputchar(buff[curr_pntr++]); - } - myputchar(buff[curr_pntr++]); - } - fflush(stdout); -} - -void -move_back(void) -{ - /** simply moves the cursor back one position **/ - if (curr_pntr == 0) { - putchar(_BELL); - } - else { - if (!buff_flag[curr_pntr - 1]) { - myputchar(_BKSPC); - curr_pntr--; - } - myputchar(_BKSPC); - curr_pntr--; - } - fflush(stdout); -} - -void -back_over_current_char(void) -{ - /*** simply backs over the character behind the cursor ***/ - if (curr_pntr == 0) { - putchar(_BELL); - } - else { - if (!buff_flag[curr_pntr - 1]) { - myputchar(_BKSPC); - myputchar(_BKSPC); - myputchar(_BLANK); - myputchar(_BLANK); - myputchar(_BKSPC); - myputchar(_BKSPC); - strcpy(&buff[curr_pntr - 2], - &buff[curr_pntr]); - flagcpy(&buff_flag[curr_pntr - 2], - &buff_flag[curr_pntr]); - buff_pntr -= 2; - curr_pntr -= 2; - del_print(curr_pntr, 2); - } - else { - myputchar(_BKSPC); - myputchar(_BLANK); - myputchar(_BKSPC); - strcpy(&buff[curr_pntr - 1], - &buff[curr_pntr]); - flagcpy(&buff_flag[curr_pntr - 1], - &buff_flag[curr_pntr]); - curr_pntr--; - buff_pntr--; - del_print(curr_pntr, 1); - } - } - fflush(stdout); - return; -} - -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/sockio-c.c b/src/lib/sockio-c.c new file mode 100644 index 00000000..f1ab39c8 --- /dev/null +++ b/src/lib/sockio-c.c @@ -0,0 +1,1191 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* socket i/o primitives */ + +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include "com.h" +#include "bsdsignal.h" + +#define TotalMaxPurposes 50 +#define MaxServerNumbers 100 +#define accept_if_needed(purpose) \ + ( purpose_table[purpose] == NULL ? sock_accept_connection(purpose) : 1 ) + +/* Note that the name AF_LOCAL is more portable than AF_UNIX, but MingW + implementation and Windows documentation don't always agree. */ + +#if HAVE_AF_LOCAL +# define AXIOM_AF_LOCAL AF_LOCAL +#elif HAVE_AF_UNIX +# define AXIOM_AF_LOCAL AF_UNIX +#else +# error needs one of AF_LOCAL or AF_UNIX +#endif + + + +Sock clients[MaxClients]; /* socket description of spad clients */ +Sock server[2]; /* AF_LOCAL and AF_INET sockets for server */ +Sock *purpose_table[TotalMaxPurposes]; /* table of dedicated socket types */ +fd_set socket_mask; /* bit mask of active sockets */ +fd_set server_mask; /* bit mask of server sockets */ +int socket_closed; /* used to identify closed socket on SIGPIPE */ +int spad_server_number = -1; /* spad server number used in sman */ +int str_len = 0; +int still_reading = 0; + + + +#include "bsdsignal.H1" +#include "sockio-c.H1" + +/* The function sleep is not available under Windows. Instead they + have Sleep(), with capital S, please. Furthermore, it does not + take argument in second, but in milliseconds, three order + of magnitude of difference when compared to the Unix world. + We abstract over that difference here. */ + +static inline void +axiom_sleep(int n) +{ +#ifdef __WIN32__ + Sleep(n * 1000); +#else + sleep(n); +#endif +} + +/* Windows require some handshaking with the WinSock DLL before + we can even think about talking about sockets. */ + +static void +axiom_load_socket_module() +{ +#ifdef __WIN32__ + WSADATA wsaData; + + /* Request version 2.0 of WinSock DLL. */ + if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0) { + perror("could not find suitable WinSock DLL."); + exit(WSAGetLastError()); + } + + if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) { + perror("could not find suitable WinSock DLL."); + WSACleanup(); + exit(WSAGetLastError()); + } +#endif +} + + +/* Get a socket identifier to a local server. We take whatever protocol + is the default for the address family in the SOCK_STREAM type. */ +static inline axiom_socket +axiom_communication_link(int family) +{ + axiom_load_socket_module(); + return socket(family, SOCK_STREAM, 0); +} + + +/* Returns 1 if SOCKET is an invalid socket. Otherwise return 0. */ + +static inline int +is_invalid_socket(const Sock* s) +{ +#ifdef __WIN32__ + return s->socket == INVALID_SOCKET; +#else + return s->socket < 0; +#endif +} + +/* Returns 1 if SOCKET is a valid socket. Otherwise return 0. */ + +static inline int +is_valid_socket(const Sock* s) +{ +#ifdef __WIN32__ + return s->socket != INVALID_SOCKET; +#else + return s->socket > 0; +#endif +} + + +/* Because a socket on Windows platform is a not just a simple file + descriptor as it is in the Unix world, it is invalid to use + a socket identifier as argument for read(), or close, and + any other file descriptor function. Furthermore, Windows + requires cleanup. */ + +void +axiom_close_socket(axiom_socket s) +{ +#ifdef __WIN32__ + shutdown(s, SD_BOTH); + closesocket(s); + WSACleanup(); +#else + close(s); +#endif +} + +/* Return 1 is the last call was cancelled. */ + +static inline int +axiom_call_was_cancelled(void) +{ +#ifdef __WIN32__ + return WSAGetLastError() == WSAEINTR; +#else + return errno == EINTR; +#endif +} + +/* Return 1 is last connect() was refused. */ + +static inline int +axiom_connection_refused(void) +{ +#ifdef __WIN32__ + return WSAGetLastError() == WSAECONNREFUSED; +#else + return errno == ECONNREFUSED; +#endif +} + + +void +sigpipe_handler(int sig) +{ + socket_closed = 1; +} + +int +wait_for_client_read(Sock *sock, char *buf, int buf_size, char *msg) +{ + int ret_val; + switch(sock->purpose) { + case SessionManager: + case ViewportServer: + sock_accept_connection(sock->purpose); + ret_val = sread(purpose_table[sock->purpose], buf, buf_size, msg); + sock->socket = 0; + return ret_val; + default: + sock->socket = 0; + return -1; + } +} + +int +wait_for_client_write(Sock *sock,char *buf,int buf_size,char *msg) +{ + int ret_val; + switch(sock->purpose) { + case SessionManager: + case ViewportServer: + sock_accept_connection(sock->purpose); + ret_val = swrite(purpose_table[sock->purpose], buf, buf_size, msg); + sock->socket = 0; + return ret_val; + default: + sock->socket = 0; + return -1; + } +} + +int +sread(Sock *sock, char *buf, int buf_size, char *msg) +{ + int ret_val; + char err_msg[256]; + errno = 0; + do { + ret_val = axiom_read(sock, buf, buf_size); + } while (ret_val == -1 && axiom_call_was_cancelled()); + if (ret_val == 0) { + FD_CLR(sock->socket, &socket_mask); + purpose_table[sock->purpose] = NULL; + axiom_close_socket(sock->socket); + return wait_for_client_read(sock, buf, buf_size, msg); + } + if (ret_val == -1) { + if (msg) { + sprintf(err_msg, "reading: %s", msg); + perror(err_msg); + } + return -1; + } + return ret_val; +} + +int +swrite(Sock *sock,char *buf,int buf_size,char *msg) +{ + int ret_val; + char err_msg[256]; + errno = 0; + socket_closed = 0; + ret_val = axiom_write(sock, buf, buf_size); + if (ret_val == -1) { + if (socket_closed) { + FD_CLR(sock->socket, &socket_mask); + purpose_table[sock->purpose] = NULL; + /* printf(" closing socket %d\n", sock->socket); */ + axiom_close_socket(sock->socket); + return wait_for_client_write(sock, buf, buf_size, msg); + } else { + if (msg) { + sprintf(err_msg, "writing: %s", msg); + perror(err_msg); + } + return -1; + } + } + return ret_val; +} + +int +sselect(int n,fd_set *rd, fd_set *wr, fd_set *ex, void *timeout) +{ + int ret_val; + do { + ret_val = select(n, (void *)rd, (void *)wr, (void *)ex, (struct timeval *) timeout); + } while (ret_val == -1 && axiom_call_was_cancelled()); + return ret_val; +} + +int +fill_buf(Sock *sock,char *buf, int len, char *msg) +{ + int bytes = 0, ret_val; + while(bytes < len) { + ret_val = sread(sock, buf + bytes, len - bytes, msg); + if (ret_val == -1) return -1; + bytes += ret_val; + } + return bytes; +} + +int +get_int(Sock *sock) +{ + int val = -1, len; + len = fill_buf(sock, (char *)&val, sizeof(int), "integer"); + if (len != sizeof(int)) { +#ifdef DEBUG + fprintf(stderr,"get_int: caught error\n",val); +#endif + return -1; + } +#ifdef DEBUG + fprintf(stderr,"get_int: received %d\n",val); +#endif + return val; +} + +int +sock_get_int(int purpose) +{ + if (accept_if_needed(purpose) != -1) + return get_int(purpose_table[purpose]); + else return -1; +} + +int +get_ints(Sock *sock, int *vals, int num) +{ + int i; + for(i=0; i 1023) { + char *buf; + buf = malloc(len+1); + strncpy(buf,str,len); + buf[len]='\0'; + send_int(sock,len+1); + val = swrite(sock, buf, len+1, NULL); + free(buf); + } else { + static char buf[1024]; + strncpy(buf, str, len); + buf[len] = '\0'; + send_int(sock, len+1); + val = swrite(sock, buf, len+1, NULL); + } + if (val == -1) { + return -1; + } + return 0; +} + +int +send_string(Sock *sock, char *str) +{ + int val, len = strlen(str); + send_int(sock, len+1); + val = swrite(sock, str, len+1, NULL); + if (val == -1) { + return -1; + } + return 0; +} + + +int +sock_send_string(int purpose, char *str) +{ + if (accept_if_needed(purpose) != -1) + return send_string(purpose_table[purpose], str); + return -1; +} + +int +sock_send_string_len(int purpose, char * str, int len) +{ + if (accept_if_needed(purpose) != -1) + return send_string_len(purpose_table[purpose], str, len); + return -1; +} + +int +send_strings(Sock *sock, char ** vals, int num) +{ + int i; + for(i=0; i buf_len) { + val = fill_buf(sock, buf, buf_len, "buffered string"); + str_len = str_len - buf_len; + if (val == -1) + return NULL; + return buf; + } + else { + val = fill_buf(sock, buf, str_len, "buffered string"); + str_len = 0; + if (val == -1) + return NULL; + return NULL; + } +} + +char * +sock_get_string_buf(int purpose, char * buf, int buf_len) +{ + if (accept_if_needed(purpose) != -1) + return get_string_buf(purpose_table[purpose], buf, buf_len); + return NULL; +} + +int +get_strings(Sock *sock,char **vals,int num) +{ + int i; + for(i=0; ipurpose) { + case SessionManager: + case ViewportServer: + sock_accept_connection(sock->purpose); + ret_val = send_signal(purpose_table[sock->purpose], sig); + sock->socket = 0; + return ret_val; + default: + sock->socket = 0; + return -1; + } +} + + +int +sock_get_remote_fd(int purpose) +{ + if (accept_if_needed(purpose) != -1) + return purpose_table[purpose]->remote; + return -1; +} + +int +send_signal(Sock *sock, int sig) +{ + int ret_val; +#if HAVE_DECL_KILL + ret_val = kill(sock->pid, sig); +#else + ret_val = raise(sig); +#endif + if (ret_val == -1 && errno == ESRCH) { + FD_CLR(sock->socket, &socket_mask); + purpose_table[sock->purpose] = NULL; +/* printf(" closing socket %d\n", sock->socket); */ + axiom_close_socket(sock->socket); + return wait_for_client_kill(sock, sig); + } + return ret_val; +} + +int +sock_send_signal(int purpose,int sig) +{ + if (accept_if_needed(purpose) != -1) + return send_signal(purpose_table[purpose], sig); + return -1; +} + +int +send_wakeup(Sock *sock) +{ +#ifdef SIGUSR1 + return send_signal(sock, SIGUSR1); +#else + return -1; +#endif +} + +int +sock_send_wakeup(int purpose) +{ + if (accept_if_needed(purpose) != -1) + return send_wakeup(purpose_table[purpose]); + return -1; +} + +Sock * +connect_to_local_server_new(char *server_name, int purpose, int time_out) +{ + int max_con=(time_out == 0 ? 1000000 : time_out), i, code=-1; + Sock *sock; + char name[256]; + + make_server_name(name, server_name); + sock = (Sock *) calloc(sizeof(Sock), 1); + if (sock == NULL) { + perror("allocating socket space"); + return NULL; + } + + sock->socket = axiom_communication_link(AXIOM_AF_LOCAL); + if (is_invalid_socket(sock)) { + perror("opening client socket"); + free(sock); + return NULL; + } + + memset(server[1].addr.u_addr.sa_data, 0, + sizeof(server[1].addr.u_addr.sa_data)); + sock->addr.u_addr.sa_family = AXIOM_AF_LOCAL; + strcpy(sock->addr.u_addr.sa_data, name); + for(i=0; isocket, &sock->addr.u_addr, + sizeof(sock->addr.u_addr)); + if (code == -1) { + if (errno != ENOENT && !axiom_connection_refused()) { + perror("connecting server stream socket"); + return NULL; + } else { + if (i != max_con - 1) + axiom_sleep(1); + continue; + } + } else break; + } + + if (code == -1) { + return NULL; + } + + send_int(sock, getpid()); + send_int(sock, purpose); + send_int(sock, sock->socket); + sock->pid = get_int(sock); + sock->remote = get_int(sock); + return sock; +} + +Sock * +connect_to_local_server(char *server_name, int purpose, int time_out) +{ + int max_con=(time_out == 0 ? 1000000 : time_out), i, code=-1; + Sock *sock; + char name[256]; + + make_server_name(name, server_name); + sock = (Sock *) calloc(sizeof(Sock), 1); + if (sock == NULL) { + perror("allocating socket space"); + return NULL; + } + + sock->purpose = purpose; + /* create the socket */ + sock->socket = axiom_communication_link(AXIOM_AF_LOCAL); + if (is_invalid_socket(sock)) { + perror("opening client socket"); + free(sock); + return NULL; + } + /* connect socket using name specified in command line */ + memset(server[1].addr.u_addr.sa_data, 0, + sizeof(server[1].addr.u_addr.sa_data)); + sock->addr.u_addr.sa_family = AXIOM_AF_LOCAL; + strcpy(sock->addr.u_addr.sa_data, name); + for(i=0; isocket, &sock->addr.u_addr, + sizeof(sock->addr.u_addr)); + if (code == -1) { + if (errno != ENOENT && !axiom_connection_refused()) { + perror("connecting server stream socket"); + return NULL; + } else { + if (i != max_con - 1) + axiom_sleep(1); + continue; + } + } else break; + } + if (code == -1) { + return NULL; + } + send_int(sock, getpid()); + send_int(sock, sock->purpose); + send_int(sock, sock->socket); + sock->pid = get_int(sock); +/* fprintf(stderr, "Got int form socket\n"); */ + sock->remote = get_int(sock); + return sock; +} + +/* act as terminal session for sock connected to stdin and stdout of another + process */ +void +remote_stdio(Sock *sock) +{ + char buf[1024]; + fd_set rd; + int len; + while (1) { + FD_ZERO(&rd); + FD_SET(sock->socket,&rd); + FD_SET(0, &rd); + len = sselect(FD_SETSIZE, (fd_set *)&rd, (fd_set *)0, (fd_set *)0, NULL); + if (len == -1) { + perror("stdio select"); + return; + } + if (FD_ISSET(0, &rd)) { + fgets(buf,1024,stdin); + len = strlen(buf); + /* + gets(buf); + len = strlen(buf); + *(buf+len) = '\n'; + *(buf+len+1) = '\0'; + */ + swrite(sock, buf, len, "writing to remote stdin"); + } + if (FD_ISSET(sock->socket, &rd)) { + len = sread(sock, buf, 1024, "stdio"); + if (len == -1) + return; + else { + *(buf + len) = '\0'; + fputs(buf, stdout); + fflush(stdout); + } + } + } +} + +/* initialize the table of dedicated sockets */ +void +init_purpose_table(void) +{ + int i; + for(i=0; isocket, 0, 0); + if (is_invalid_socket(&clients[client])) { + perror("accept_connection"); + clients[client].socket = 0; + return -1; + } + FD_SET(clients[client].socket, &socket_mask); + get_socket_type(clients+client); + return clients[client].purpose; +} + +/* reads a the socket purpose declaration for classification */ +void +get_socket_type(Sock *sock) +{ + sock->pid = get_int(sock); + sock->purpose = get_int(sock); + sock->remote = get_int(sock); + send_int(sock, getpid()); + send_int(sock, sock->socket); + purpose_table[sock->purpose] = sock; + switch (sock->purpose) { + case SessionManager: + break; + case ViewportServer: + break; + case MenuServer: + break; + case SessionIO: +/* redirect_stdio(sock); */ + break; + } +} + +int +sock_accept_connection(int purpose) +{ + fd_set rd; + int ret_val, i, p; + if (getenv("SPADNUM") == NULL) return -1; + while (1) { + rd = server_mask; + ret_val = sselect(FD_SETSIZE, (fd_set *)&rd, (fd_set *)0, (fd_set *)0, NULL); + if (ret_val == -1) { + /* perror ("Select"); */ + return -1; + } + for(i=0; i<2; i++) { + if (is_valid_socket(&server[i]) + && FD_ISSET(server[i].socket, &rd)) { + p = accept_connection(server+i); + if (p == purpose) return 1; + } + } + } +} + +/* direct stdin and stdout from the given socket */ +void +redirect_stdio(Sock *sock) +{ + int fd; +/* setbuf(stdout, NULL); */ + fd = dup2(sock->socket, 1); + if (fd != 1) { + fprintf(stderr, "Error connecting stdout to socket\n"); + return; + } + fd = dup2(sock->socket, 0); + if (fd != 0) { + fprintf(stderr, "Error connecting stdin to socket\n"); + return; + } + fprintf(stderr, "Redirected standard IO\n"); + FD_CLR(sock->socket, &socket_mask); +} + +void +init_socks(void) +{ + int i; + FD_ZERO(&socket_mask); + FD_ZERO(&server_mask); + init_purpose_table(); + for(i=0; i<2; i++) server[i].socket = 0; + for(i=0; isocket, &fds_mask); + } + while (1) { + do { + if (purpose_table[MenuServer] != NULL) { + FD_SET(purpose_table[MenuServer]->socket, &fds_mask); + } + rd = fds_mask; + ret_val = select(FD_SETSIZE, (void *) &rd, (void *) 0, (void *) 0, (void *) 0); + if (ret_val == -1) { + /* perror ("Select in switch"); */ + return -1; + } + for(i=0; i<2; i++) { + if (is_valid_socket(&server[i]) + && (FD_ISSET(server[i].socket, &rd))) + accept_connection(server+i); + } + } while (purpose_table[SessionManager] == NULL); + FD_SET(purpose_table[SessionManager]->socket, &fds_mask); + if (FD_ISSET(purpose_table[SessionManager]->socket, &rd)) { + cmd = get_int(purpose_table[SessionManager]); + return cmd; + } + if (FD_ISSET(0, &rd)) { + return CallInterp; + } + if (purpose_table[MenuServer] != NULL && + (FD_ISSET(purpose_table[MenuServer]->socket, &rd))) { + cmd = get_int(purpose_table[MenuServer]); + return cmd; + } + } +} + +void +flush_stdout(void) +{ + static FILE *fp = NULL; + if (fp == NULL) { + fp = fdopen(purpose_table[SessionIO]->socket, "w"); + if (fp == NULL) { + perror("fdopen"); + return; + } + } + fflush(fp); +} + +void +print_line(char *s) +{ + printf("%s\n", s); +} + + +typedef union { + double f; + long l[2]; + } DoubleFloat; + +double +plus_infinity(void ) +{ + static int init = 0; + static DoubleFloat pinf; + if (! init) { + pinf.l[0] = 0x7ff00000; + pinf.l[1] = 0; + init = 1; + } + return pinf.f; +} + +double +minus_infinity(void) +{ + static int init = 0; + static DoubleFloat minf; + if (! init) { + minf.l[0] = 0xfff00000L; + minf.l[1] = 0; + init = 1; + } + return minf.f; +} + +double +NANQ(void) +{ + static int init = 0; + static DoubleFloat nanq; + if (! init) { + nanq.l[0] = 0x7ff80000L; + nanq.l[1] = 0; + init = 1; + } + return nanq.f; +} diff --git a/src/lib/sockio-c.c.pamphlet b/src/lib/sockio-c.c.pamphlet deleted file mode 100644 index 184a5ff5..00000000 --- a/src/lib/sockio-c.c.pamphlet +++ /dev/null @@ -1,1218 +0,0 @@ -\documentclass{article} -\usepackage{axiom} - -\title{\$SPAD/src/lib sockio-c.c} -\author{The Axiom Team} - -\begin{document} -\maketitle - -\begin{abstract} -\end{abstract} -\eject - -\tableofcontents -\eject - -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -/* socket i/o primitives */ - -#include -#include - -#include -#include -#include -#include - -#include -#include -#include - -#include "com.h" -#include "bsdsignal.h" - -#define TotalMaxPurposes 50 -#define MaxServerNumbers 100 -#define accept_if_needed(purpose) \ - ( purpose_table[purpose] == NULL ? sock_accept_connection(purpose) : 1 ) - -/* Note that the name AF_LOCAL is more portable than AF_UNIX, but MingW - implementation and Windows documentation don't always agree. */ - -#if HAVE_AF_LOCAL -# define AXIOM_AF_LOCAL AF_LOCAL -#elif HAVE_AF_UNIX -# define AXIOM_AF_LOCAL AF_UNIX -#else -# error needs one of AF_LOCAL or AF_UNIX -#endif - - - -Sock clients[MaxClients]; /* socket description of spad clients */ -Sock server[2]; /* AF_LOCAL and AF_INET sockets for server */ -Sock *purpose_table[TotalMaxPurposes]; /* table of dedicated socket types */ -fd_set socket_mask; /* bit mask of active sockets */ -fd_set server_mask; /* bit mask of server sockets */ -int socket_closed; /* used to identify closed socket on SIGPIPE */ -int spad_server_number = -1; /* spad server number used in sman */ -int str_len = 0; -int still_reading = 0; - - - -#include "bsdsignal.H1" -#include "sockio-c.H1" - -/* The function sleep is not available under Windows. Instead they - have Sleep(), with capital S, please. Furthermore, it does not - take argument in second, but in milliseconds, three order - of magnitude of difference when compared to the Unix world. - We abstract over that difference here. */ - -static inline void -axiom_sleep(int n) -{ -#ifdef __WIN32__ - Sleep(n * 1000); -#else - sleep(n); -#endif -} - -/* Windows require some handshaking with the WinSock DLL before - we can even think about talking about sockets. */ - -static void -axiom_load_socket_module() -{ -#ifdef __WIN32__ - WSADATA wsaData; - - /* Request version 2.0 of WinSock DLL. */ - if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0) { - perror("could not find suitable WinSock DLL."); - exit(WSAGetLastError()); - } - - if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) { - perror("could not find suitable WinSock DLL."); - WSACleanup(); - exit(WSAGetLastError()); - } -#endif -} - - -/* Get a socket identifier to a local server. We take whatever protocol - is the default for the address family in the SOCK_STREAM type. */ -static inline axiom_socket -axiom_communication_link(int family) -{ - axiom_load_socket_module(); - return socket(family, SOCK_STREAM, 0); -} - - -/* Returns 1 if SOCKET is an invalid socket. Otherwise return 0. */ - -static inline int -is_invalid_socket(const Sock* s) -{ -#ifdef __WIN32__ - return s->socket == INVALID_SOCKET; -#else - return s->socket < 0; -#endif -} - -/* Returns 1 if SOCKET is a valid socket. Otherwise return 0. */ - -static inline int -is_valid_socket(const Sock* s) -{ -#ifdef __WIN32__ - return s->socket != INVALID_SOCKET; -#else - return s->socket > 0; -#endif -} - - -/* Because a socket on Windows platform is a not just a simple file - descriptor as it is in the Unix world, it is invalid to use - a socket identifier as argument for read(), or close, and - any other file descriptor function. Furthermore, Windows - requires cleanup. */ - -void -axiom_close_socket(axiom_socket s) -{ -#ifdef __WIN32__ - shutdown(s, SD_BOTH); - closesocket(s); - WSACleanup(); -#else - close(s); -#endif -} - -/* Return 1 is the last call was cancelled. */ - -static inline int -axiom_call_was_cancelled(void) -{ -#ifdef __WIN32__ - return WSAGetLastError() == WSAEINTR; -#else - return errno == EINTR; -#endif -} - -/* Return 1 is last connect() was refused. */ - -static inline int -axiom_connection_refused(void) -{ -#ifdef __WIN32__ - return WSAGetLastError() == WSAECONNREFUSED; -#else - return errno == ECONNREFUSED; -#endif -} - - -void -sigpipe_handler(int sig) -{ - socket_closed = 1; -} - -int -wait_for_client_read(Sock *sock, char *buf, int buf_size, char *msg) -{ - int ret_val; - switch(sock->purpose) { - case SessionManager: - case ViewportServer: - sock_accept_connection(sock->purpose); - ret_val = sread(purpose_table[sock->purpose], buf, buf_size, msg); - sock->socket = 0; - return ret_val; - default: - sock->socket = 0; - return -1; - } -} - -int -wait_for_client_write(Sock *sock,char *buf,int buf_size,char *msg) -{ - int ret_val; - switch(sock->purpose) { - case SessionManager: - case ViewportServer: - sock_accept_connection(sock->purpose); - ret_val = swrite(purpose_table[sock->purpose], buf, buf_size, msg); - sock->socket = 0; - return ret_val; - default: - sock->socket = 0; - return -1; - } -} - -int -sread(Sock *sock, char *buf, int buf_size, char *msg) -{ - int ret_val; - char err_msg[256]; - errno = 0; - do { - ret_val = axiom_read(sock, buf, buf_size); - } while (ret_val == -1 && axiom_call_was_cancelled()); - if (ret_val == 0) { - FD_CLR(sock->socket, &socket_mask); - purpose_table[sock->purpose] = NULL; - axiom_close_socket(sock->socket); - return wait_for_client_read(sock, buf, buf_size, msg); - } - if (ret_val == -1) { - if (msg) { - sprintf(err_msg, "reading: %s", msg); - perror(err_msg); - } - return -1; - } - return ret_val; -} - -int -swrite(Sock *sock,char *buf,int buf_size,char *msg) -{ - int ret_val; - char err_msg[256]; - errno = 0; - socket_closed = 0; - ret_val = axiom_write(sock, buf, buf_size); - if (ret_val == -1) { - if (socket_closed) { - FD_CLR(sock->socket, &socket_mask); - purpose_table[sock->purpose] = NULL; - /* printf(" closing socket %d\n", sock->socket); */ - axiom_close_socket(sock->socket); - return wait_for_client_write(sock, buf, buf_size, msg); - } else { - if (msg) { - sprintf(err_msg, "writing: %s", msg); - perror(err_msg); - } - return -1; - } - } - return ret_val; -} - -int -sselect(int n,fd_set *rd, fd_set *wr, fd_set *ex, void *timeout) -{ - int ret_val; - do { - ret_val = select(n, (void *)rd, (void *)wr, (void *)ex, (struct timeval *) timeout); - } while (ret_val == -1 && axiom_call_was_cancelled()); - return ret_val; -} - -int -fill_buf(Sock *sock,char *buf, int len, char *msg) -{ - int bytes = 0, ret_val; - while(bytes < len) { - ret_val = sread(sock, buf + bytes, len - bytes, msg); - if (ret_val == -1) return -1; - bytes += ret_val; - } - return bytes; -} - -int -get_int(Sock *sock) -{ - int val = -1, len; - len = fill_buf(sock, (char *)&val, sizeof(int), "integer"); - if (len != sizeof(int)) { -#ifdef DEBUG - fprintf(stderr,"get_int: caught error\n",val); -#endif - return -1; - } -#ifdef DEBUG - fprintf(stderr,"get_int: received %d\n",val); -#endif - return val; -} - -int -sock_get_int(int purpose) -{ - if (accept_if_needed(purpose) != -1) - return get_int(purpose_table[purpose]); - else return -1; -} - -int -get_ints(Sock *sock, int *vals, int num) -{ - int i; - for(i=0; i 1023) { - char *buf; - buf = malloc(len+1); - strncpy(buf,str,len); - buf[len]='\0'; - send_int(sock,len+1); - val = swrite(sock, buf, len+1, NULL); - free(buf); - } else { - static char buf[1024]; - strncpy(buf, str, len); - buf[len] = '\0'; - send_int(sock, len+1); - val = swrite(sock, buf, len+1, NULL); - } - if (val == -1) { - return -1; - } - return 0; -} - -int -send_string(Sock *sock, char *str) -{ - int val, len = strlen(str); - send_int(sock, len+1); - val = swrite(sock, str, len+1, NULL); - if (val == -1) { - return -1; - } - return 0; -} - - -int -sock_send_string(int purpose, char *str) -{ - if (accept_if_needed(purpose) != -1) - return send_string(purpose_table[purpose], str); - return -1; -} - -int -sock_send_string_len(int purpose, char * str, int len) -{ - if (accept_if_needed(purpose) != -1) - return send_string_len(purpose_table[purpose], str, len); - return -1; -} - -int -send_strings(Sock *sock, char ** vals, int num) -{ - int i; - for(i=0; i buf_len) { - val = fill_buf(sock, buf, buf_len, "buffered string"); - str_len = str_len - buf_len; - if (val == -1) - return NULL; - return buf; - } - else { - val = fill_buf(sock, buf, str_len, "buffered string"); - str_len = 0; - if (val == -1) - return NULL; - return NULL; - } -} - -char * -sock_get_string_buf(int purpose, char * buf, int buf_len) -{ - if (accept_if_needed(purpose) != -1) - return get_string_buf(purpose_table[purpose], buf, buf_len); - return NULL; -} - -int -get_strings(Sock *sock,char **vals,int num) -{ - int i; - for(i=0; ipurpose) { - case SessionManager: - case ViewportServer: - sock_accept_connection(sock->purpose); - ret_val = send_signal(purpose_table[sock->purpose], sig); - sock->socket = 0; - return ret_val; - default: - sock->socket = 0; - return -1; - } -} - - -int -sock_get_remote_fd(int purpose) -{ - if (accept_if_needed(purpose) != -1) - return purpose_table[purpose]->remote; - return -1; -} - -int -send_signal(Sock *sock, int sig) -{ - int ret_val; -#if HAVE_DECL_KILL - ret_val = kill(sock->pid, sig); -#else - ret_val = raise(sig); -#endif - if (ret_val == -1 && errno == ESRCH) { - FD_CLR(sock->socket, &socket_mask); - purpose_table[sock->purpose] = NULL; -/* printf(" closing socket %d\n", sock->socket); */ - axiom_close_socket(sock->socket); - return wait_for_client_kill(sock, sig); - } - return ret_val; -} - -int -sock_send_signal(int purpose,int sig) -{ - if (accept_if_needed(purpose) != -1) - return send_signal(purpose_table[purpose], sig); - return -1; -} - -int -send_wakeup(Sock *sock) -{ -#ifdef SIGUSR1 - return send_signal(sock, SIGUSR1); -#else - return -1; -#endif -} - -int -sock_send_wakeup(int purpose) -{ - if (accept_if_needed(purpose) != -1) - return send_wakeup(purpose_table[purpose]); - return -1; -} - -Sock * -connect_to_local_server_new(char *server_name, int purpose, int time_out) -{ - int max_con=(time_out == 0 ? 1000000 : time_out), i, code=-1; - Sock *sock; - char name[256]; - - make_server_name(name, server_name); - sock = (Sock *) calloc(sizeof(Sock), 1); - if (sock == NULL) { - perror("allocating socket space"); - return NULL; - } - - sock->socket = axiom_communication_link(AXIOM_AF_LOCAL); - if (is_invalid_socket(sock)) { - perror("opening client socket"); - free(sock); - return NULL; - } - - memset(server[1].addr.u_addr.sa_data, 0, - sizeof(server[1].addr.u_addr.sa_data)); - sock->addr.u_addr.sa_family = AXIOM_AF_LOCAL; - strcpy(sock->addr.u_addr.sa_data, name); - for(i=0; isocket, &sock->addr.u_addr, - sizeof(sock->addr.u_addr)); - if (code == -1) { - if (errno != ENOENT && !axiom_connection_refused()) { - perror("connecting server stream socket"); - return NULL; - } else { - if (i != max_con - 1) - axiom_sleep(1); - continue; - } - } else break; - } - - if (code == -1) { - return NULL; - } - - send_int(sock, getpid()); - send_int(sock, purpose); - send_int(sock, sock->socket); - sock->pid = get_int(sock); - sock->remote = get_int(sock); - return sock; -} - -Sock * -connect_to_local_server(char *server_name, int purpose, int time_out) -{ - int max_con=(time_out == 0 ? 1000000 : time_out), i, code=-1; - Sock *sock; - char name[256]; - - make_server_name(name, server_name); - sock = (Sock *) calloc(sizeof(Sock), 1); - if (sock == NULL) { - perror("allocating socket space"); - return NULL; - } - - sock->purpose = purpose; - /* create the socket */ - sock->socket = axiom_communication_link(AXIOM_AF_LOCAL); - if (is_invalid_socket(sock)) { - perror("opening client socket"); - free(sock); - return NULL; - } - /* connect socket using name specified in command line */ - memset(server[1].addr.u_addr.sa_data, 0, - sizeof(server[1].addr.u_addr.sa_data)); - sock->addr.u_addr.sa_family = AXIOM_AF_LOCAL; - strcpy(sock->addr.u_addr.sa_data, name); - for(i=0; isocket, &sock->addr.u_addr, - sizeof(sock->addr.u_addr)); - if (code == -1) { - if (errno != ENOENT && !axiom_connection_refused()) { - perror("connecting server stream socket"); - return NULL; - } else { - if (i != max_con - 1) - axiom_sleep(1); - continue; - } - } else break; - } - if (code == -1) { - return NULL; - } - send_int(sock, getpid()); - send_int(sock, sock->purpose); - send_int(sock, sock->socket); - sock->pid = get_int(sock); -/* fprintf(stderr, "Got int form socket\n"); */ - sock->remote = get_int(sock); - return sock; -} - -/* act as terminal session for sock connected to stdin and stdout of another - process */ -void -remote_stdio(Sock *sock) -{ - char buf[1024]; - fd_set rd; - int len; - while (1) { - FD_ZERO(&rd); - FD_SET(sock->socket,&rd); - FD_SET(0, &rd); - len = sselect(FD_SETSIZE, (fd_set *)&rd, (fd_set *)0, (fd_set *)0, NULL); - if (len == -1) { - perror("stdio select"); - return; - } - if (FD_ISSET(0, &rd)) { - fgets(buf,1024,stdin); - len = strlen(buf); - /* - gets(buf); - len = strlen(buf); - *(buf+len) = '\n'; - *(buf+len+1) = '\0'; - */ - swrite(sock, buf, len, "writing to remote stdin"); - } - if (FD_ISSET(sock->socket, &rd)) { - len = sread(sock, buf, 1024, "stdio"); - if (len == -1) - return; - else { - *(buf + len) = '\0'; - fputs(buf, stdout); - fflush(stdout); - } - } - } -} - -/* initialize the table of dedicated sockets */ -void -init_purpose_table(void) -{ - int i; - for(i=0; isocket, 0, 0); - if (is_invalid_socket(&clients[client])) { - perror("accept_connection"); - clients[client].socket = 0; - return -1; - } - FD_SET(clients[client].socket, &socket_mask); - get_socket_type(clients+client); - return clients[client].purpose; -} - -/* reads a the socket purpose declaration for classification */ -void -get_socket_type(Sock *sock) -{ - sock->pid = get_int(sock); - sock->purpose = get_int(sock); - sock->remote = get_int(sock); - send_int(sock, getpid()); - send_int(sock, sock->socket); - purpose_table[sock->purpose] = sock; - switch (sock->purpose) { - case SessionManager: - break; - case ViewportServer: - break; - case MenuServer: - break; - case SessionIO: -/* redirect_stdio(sock); */ - break; - } -} - -int -sock_accept_connection(int purpose) -{ - fd_set rd; - int ret_val, i, p; - if (getenv("SPADNUM") == NULL) return -1; - while (1) { - rd = server_mask; - ret_val = sselect(FD_SETSIZE, (fd_set *)&rd, (fd_set *)0, (fd_set *)0, NULL); - if (ret_val == -1) { - /* perror ("Select"); */ - return -1; - } - for(i=0; i<2; i++) { - if (is_valid_socket(&server[i]) - && FD_ISSET(server[i].socket, &rd)) { - p = accept_connection(server+i); - if (p == purpose) return 1; - } - } - } -} - -/* direct stdin and stdout from the given socket */ -void -redirect_stdio(Sock *sock) -{ - int fd; -/* setbuf(stdout, NULL); */ - fd = dup2(sock->socket, 1); - if (fd != 1) { - fprintf(stderr, "Error connecting stdout to socket\n"); - return; - } - fd = dup2(sock->socket, 0); - if (fd != 0) { - fprintf(stderr, "Error connecting stdin to socket\n"); - return; - } - fprintf(stderr, "Redirected standard IO\n"); - FD_CLR(sock->socket, &socket_mask); -} - -void -init_socks(void) -{ - int i; - FD_ZERO(&socket_mask); - FD_ZERO(&server_mask); - init_purpose_table(); - for(i=0; i<2; i++) server[i].socket = 0; - for(i=0; isocket, &fds_mask); - } - while (1) { - do { - if (purpose_table[MenuServer] != NULL) { - FD_SET(purpose_table[MenuServer]->socket, &fds_mask); - } - rd = fds_mask; - ret_val = select(FD_SETSIZE, (void *) &rd, (void *) 0, (void *) 0, (void *) 0); - if (ret_val == -1) { - /* perror ("Select in switch"); */ - return -1; - } - for(i=0; i<2; i++) { - if (is_valid_socket(&server[i]) - && (FD_ISSET(server[i].socket, &rd))) - accept_connection(server+i); - } - } while (purpose_table[SessionManager] == NULL); - FD_SET(purpose_table[SessionManager]->socket, &fds_mask); - if (FD_ISSET(purpose_table[SessionManager]->socket, &rd)) { - cmd = get_int(purpose_table[SessionManager]); - return cmd; - } - if (FD_ISSET(0, &rd)) { - return CallInterp; - } - if (purpose_table[MenuServer] != NULL && - (FD_ISSET(purpose_table[MenuServer]->socket, &rd))) { - cmd = get_int(purpose_table[MenuServer]); - return cmd; - } - } -} - -void -flush_stdout(void) -{ - static FILE *fp = NULL; - if (fp == NULL) { - fp = fdopen(purpose_table[SessionIO]->socket, "w"); - if (fp == NULL) { - perror("fdopen"); - return; - } - } - fflush(fp); -} - -void -print_line(char *s) -{ - printf("%s\n", s); -} - - -typedef union { - double f; - long l[2]; - } DoubleFloat; - -double -plus_infinity(void ) -{ - static int init = 0; - static DoubleFloat pinf; - if (! init) { - pinf.l[0] = 0x7ff00000; - pinf.l[1] = 0; - init = 1; - } - return pinf.f; -} - -double -minus_infinity(void) -{ - static int init = 0; - static DoubleFloat minf; - if (! init) { - minf.l[0] = 0xfff00000L; - minf.l[1] = 0; - init = 1; - } - return minf.f; -} - -double -NANQ(void) -{ - static int init = 0; - static DoubleFloat nanq; - if (! init) { - nanq.l[0] = 0x7ff80000L; - nanq.l[1] = 0; - init = 1; - } - return nanq.f; -} -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/spadcolors.c b/src/lib/spadcolors.c new file mode 100644 index 00000000..4cd79e09 --- /dev/null +++ b/src/lib/spadcolors.c @@ -0,0 +1,533 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" +#include "spadcolors.h" + +#include +#include +#include +#include + +#include "spadcolors.H1" +#include "util.H1" + +#if 0 +int colors[100]; +#endif + +static unsigned long pixels[smoothConst+1]; + + +/* + * make sure you define a global variable like int *spadColors; in the main + * program + */ + +/* + * code taken from Foley and Van Dam "Fundamentals of Interactive Computer + * Graphics" + */ + + + +RGB +HSVtoRGB(HSV hsv) +{ + RGB rgb; + float h, f, p, q, t; + int i; + + rgb.r = 0.0; + rgb.g = 0.0; + rgb.b = 0.0; + if (hsv.s == 0.0) { + rgb.r = rgb.g = rgb.b = hsv.v; + return (rgb); + } + else { + if (hsv.h == 360.0) { + hsv.h = 0.0; + } + h = hsv.h / 60; + i = floor(h); + f = h - i; + p = hsv.v * (1 - hsv.s); + q = hsv.v * (1 - (hsv.s * f)); + t = hsv.v * (1 - (hsv.s * (1 - f))); + switch (i) { + case 0: + rgb.r = hsv.v; + rgb.g = t; + rgb.b = p; + break; + case 1: + rgb.r = q; + rgb.g = hsv.v; + rgb.b = p; + break; + case 2: + rgb.r = p; + rgb.g = hsv.v; + rgb.b = t; + break; + case 3: + rgb.r = p; + rgb.g = q; + rgb.b = hsv.v; + break; + case 4: + rgb.r = t; + rgb.g = p; + rgb.b = hsv.v; + break; + case 5: + rgb.r = hsv.v; + rgb.g = p; + rgb.b = q; + break; + } + return (rgb); + } +} + +float +value(float n1, float n2, float hue) +{ + float v; + + if (hue > 360.0) + hue -= 360.0; + if (hue < 0.0) + hue += 360.0; + if (hue < 60.0) { + v = n1 + (n2 - n1) * hue / 60.0; + } + else { + if (hue < 180.0) + v = n2; + else { + if (hue < 240.0) + v = n1 + (n2 - n1) * (240.0 - hue) / 60.0; + else + v = n1; + } + } + return (v); +} + + + +RGB +HLStoRGB(HLS hls) +{ + RGB rgb; + float m1, m2; + + if (hls.l <= 0.5) { + m2 = hls.l * (1.0 + hls.s); + } + else { + m2 = hls.l + hls.s - hls.l * hls.s; + } + m1 = 2.0 * hls.l - m2; + rgb.r = value(m1, m2, hls.h + 120.0); + rgb.g = value(m1, m2, hls.h); + rgb.b = value(m1, m2, hls.h - 120.0); + + return (rgb); +} + + +/****************************************************** + * int makeColors(dsply,scrn,colorMap,total_Shades) * + * * + * This routine tries to allocate an adequate color * + * map to be used by all the AXIOM applications * + * that are to be run under X Windows that use * + * colors that may be user-definable (e.g. viewports, * + * HyperTeX, etc). All these application should call * + * this routine and then access the colors with the * + * the returned color map. * + * For example, the following creates the map and * + * then sets the foreground color for a GC: * + * * + * i = makeColors(d,s,&cmap,&spadColors,&ts); * + * XSetForegroundColor(d,gc,spadColors[3]); * + * * + * where * + * spadColors is of type (unsigned long *) * + * i (the return value) is the total number of colors * + * allocated. * + * ts is the total number of shades for each hue * + * * + * KF 6/14/90 (modification) * + * makeColors creates color table once only. * + * hiya is of type static. * + ******************************************************/ + +int +makeColors(Display *dsply, int scrn, Colormap *colorMap, + unsigned long **colorIndex, int *total_Shades) +{ + + int h, s; + static unsigned long *hiya; /* keep colortable around for next time */ + HSV hsv; + RGB rgb; + XColor color; + int okay = yes; /* is true (1) so long as XAllocColor is + * working ok. if 0, then we ran out of room + * on the color table. */ + int colorNum; + + /* shade5 definition */ + + static float saturations[5] = {0.90, 0.80, 0.74, 0.50, 0.18}; + static float values[5] = {0.38, 0.58, 0.75, 0.88, 0.94}; + + /* static float values[5] = {0.34, 0.52, 0.80, 0.88, 0.94}; */ + + /* fprintf(stderr,"makeColors called\n");*/ + + /* printf("making new colors....\n"); */ + *total_Shades = totalShadesConst; + + /* space for color table */ + hiya = (unsigned long *) saymem("spadcolors30.c", totalHuesConst * (*total_Shades) + 2, sizeof(unsigned long)); + *colorIndex = hiya; + + for (h = 0, colorNum = 0; okay && h < 60; h += (hueStep - 6)) { + for (s = 0; okay && s < *total_Shades; s++) { + hsv.h = h; + hsv.s = saturations[s]; + hsv.v = values[s]; + rgb = HSVtoRGB(hsv); + color.red = rgb.r *((1<<16)-1); + color.green = rgb.g *((1<<16)-1); + color.blue = rgb.b *((1<<16)-1); + color.flags = DoRed | DoGreen | DoBlue; + /* + fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); + fprintf(stderr,"%d\t%d\t%d\n",color.red,color.green,color.blue); + */ + if ((okay = XAllocColor(dsply, *colorMap, &color))) + hiya[colorNum++] = color.pixel; /* hiya points to table */ + } /* for s */ + } /* for h */ + for (h = 60; okay && h < 180; h += 20) { + for (s = 0; okay && s < *total_Shades; s++) { + hsv.h = h; + hsv.s = saturations[s]; + hsv.v = values[s]; + rgb = HSVtoRGB(hsv); + + color.red = rgb.r *((1<<16)-1); + color.green = rgb.g *((1<<16)-1); + color.blue = rgb.b *((1<<16)-1); + color.flags = DoRed | DoGreen | DoBlue; + /* + fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); + fprintf(stderr,"%d\t%d\t%d\n",color.red,color.green,color.blue); + */ + + if ((okay = XAllocColor(dsply, *colorMap, &color))) + hiya[colorNum++] = color.pixel; + } + } + + for (h = 180; okay && h <= 300; h += hueStep) { + for (s = 0; okay && s < *total_Shades; s++) { + hsv.h = h; + hsv.s = saturations[s]; + hsv.v = values[s]; + rgb = HSVtoRGB(hsv); + + color.red = rgb.r *((1<<16)-1); + color.green = rgb.g *((1<<16)-1); + color.blue = rgb.b *((1<<16)-1); + color.flags = DoRed | DoGreen | DoBlue; + /* + fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); + fprintf(stderr,"%d\t%d\t%d\n",color.red,color.green,color.blue); + */ + if ((okay = XAllocColor(dsply, *colorMap, &color))) + hiya[colorNum++] = color.pixel; + } + } + + hiya[colorNum++] = BlackPixel(dsply, scrn); + hiya[colorNum++] = WhitePixel(dsply, scrn); + + if (colorNum < (totalShadesConst * totalHuesConst + 2)) { + free(*colorIndex); + fprintf(stderr, + " > Warning: cannot allocate all the necessary colors - switching to monochrome mode\n"); + *colorIndex = (unsigned long *) saymem("while allocating the colormap for AXIOM ", 2, sizeof(unsigned long)); + (*colorIndex)[0] = BlackPixel(dsply, scrn); + (*colorIndex)[1] = WhitePixel(dsply, scrn); + return (-1); + } + + return (colorNum); +} + +#ifdef OLD +/*********************************************************************** + KF 6/14/90 + INPUT: display dsply, screen scrn + OUTPUT: a pointer to the permutation color vector (permIndex) + PURPOSE: when called for the first time, this procedure creates a + permutation vector of the color table spadColor. It + returns the pointer to this vector for subsequent calls. + +***********************************************************************/ + +int +makePermVector(Display *dsply, int scrn, unsigned long **permIndex) +{ + static int firstTime = yes; + unsigned long *spadColorsToo; + static unsigned long *pIndex; + Colormap cmap; + int num_colors; + int i, ts; + + if (firstTime) { + + /* initialization */ + + cmap = DefaultColormap(dsply, scrn); /* what are other cmaps?? */ + pIndex = (unsigned long *) saymem("makePermVector", Colorcells, sizeof(unsigned long)); + + /* get spadColors table */ + + if ((num_colors = makeColors(dsply, scrn, &cmap, &spadColorsToo, &ts)) < 0) { + printf("num_colors < 0!!\n"); + exit(-1); + } + + /* initialize unused slots in permutation vector */ + + for (i = 0; i < spadColorsToo[0]; i++) + pIndex[i] = 0; + for (i = num_colors; i < Colorcells; i++) + pIndex[i] = 0; + + /* make permutation vector */ + + for (i = 0; i < num_colors; i++) + pIndex[spadColorsToo[i]] = i; + + firstTime = no; + } + + *permIndex = pIndex; + return (Colorcells); +} + +#endif + +/****************************************************** + * int makeNewColorMap(dsply,colorMap,smoothHue) * + * * + * This routine tries to allocate an adequate color * + * map to be used by the AXIOM smooth shading * + * application that is to be run under X Windows. * + * The colors are allocated from available space in * + * the colorMap and returned in the array pixels. * + * The size of the array is determined by smoothConst * + * which is the number of shades desired. The colors * + * returned are variations in lightness of the hue * + * smoothHue indicated on the control panel Colormap. * + * * + * If smoothConst colors can be allocated the value * + * 1 is returned, otherwise returns 0 * + * * + ******************************************************/ + + +int +makeNewColorMap(Display *dsply, Colormap colorMap, int smoothHue) + +{ + + int count, i; + float lightness; + RGB rgb; + XColor xcolor; + HLS hls; + + count = 0; + for (i = 0; i < (smoothConst + 1); i++) { /* i = 0 .. smoothConst */ + lightness = (float) (i) / (float) (smoothConst); /* lightnes = 0.0 .. 1.0 */ + hls.h = (float) smoothHue; + hls.l = lightness; + hls.s = saturation; + rgb = HLStoRGB(hls); + + xcolor.red = rgb.r *((1<<16)-1); + xcolor.green = rgb.g *((1<<16)-1); + xcolor.blue = rgb.b *((1<<16)-1); + xcolor.flags = DoRed | DoGreen | DoBlue; + /* + fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); + fprintf(stderr,"%d\t%d\t%d\n",xcolor.red,xcolor.green,xcolor.blue); + */ + if (XAllocColor(dsply, colorMap, &xcolor)) { + pixels[count] = xcolor.pixel; + count++; + } + } + /* count says how many succeeded */ + if (count != (smoothConst+1) ) { + + /* we have failed to get all of them - free the ones we got */ + + FreePixels(dsply,colorMap,count); + return (0); + } + return (1); +} + + + +/****************************************************** + * unsigned long XPixelColor(num) * + * * + * XPixelColor is a straight forward function that * + * merely returns the XColor value desired within * + * the pixels array. For smooth shading, given an * + * intensity from 0..1, scaling by the number of * + * values in the array will return the location in * + * pixels[] of the desired color for that intensity. * + * * + ******************************************************/ + +unsigned long +XPixelColor(int num) +{ + if (num < 0) + num = 0; + return (pixels[num]); +} + + +/****************************************************** + * FreePixels(dsply,colorMap,num) * + * * + * FreePixels is a call to XFreeColors which frees * + * previously allocated colors for the indicated * + * colorMap. If it cannot free the number of colors * + * given by num a BadAccess error will crash the * + * viewport process. This should ONLY be used if * + * it can be guaranteed that there will be num colors * + * to free in colorMap. return 0 == success * + * * + ******************************************************/ + + +void +FreePixels(Display *dsply, Colormap colorMap, int num) +{ + + XFreeColors(dsply, colorMap, pixels, num, 0); +} + + + +/****************************************************** + * int AllocCells(dsply,colorMap,smoothHue) * + * * + * Use either makeNewColormap() OR AllocCells(). * + * This routine tries to allocate an adequate color * + * map to be used by the AXIOM smooth shading * + * application that is to be run under X Windows. * + * The colors are allocated from available space in * + * the colorMap and returned in the array pixels. * + * The size of the array is determined by smoothConst * + * which is the number of shades desired. The colors * + * returned are variations in lightness of the hue * + * smoothHue indicated on the control panel Colormap. * + * * + * It is different from makeNewColormap() in that * + * the cells are read/write, and if it cannot alloc * + * all the colors desired it doesn't allocate any. * + * * + ******************************************************/ + + +int +AllocCells(Display *dsply, Colormap colorMap, int smoothHue) +{ + unsigned long plane_masks[1]; + int i, count; + float lightness; + RGB rgb; + XColor xcolor; + HLS hls; + + count = 0; + for (i = 0; i < (smoothConst + 1); i++) { + lightness = (float) (i) / (float) (smoothConst); + hls.h = (float) smoothHue; + hls.l = lightness; + hls.s = saturation; + rgb = HLStoRGB(hls); + xcolor.red = rgb.r *((1<<16)-1); + xcolor.green = rgb.g *((1<<16)-1); + xcolor.blue = rgb.b *((1<<16)-1); + xcolor.flags = DoRed | DoGreen | DoBlue; + /* + fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); + fprintf(stderr,"%d\t%d\t%d\n",xcolor.red,xcolor.green,xcolor.blue); + */ + if (XAllocColor(dsply, colorMap, &xcolor)) { + pixels[count] = xcolor.pixel; + count++; + } + } + /* count says how many succeeded */ + if (count != (smoothConst+1) ) { + /* we have failed to get all of them - free the ones we got */ + FreePixels(dsply,colorMap,count); + return (0); + } + if (XAllocColorCells(dsply, colorMap, False, + plane_masks, 0, pixels, smoothConst + 1)) { + return (smoothConst + 1); + } + else { + return (0); + } +} diff --git a/src/lib/spadcolors.c.pamphlet b/src/lib/spadcolors.c.pamphlet deleted file mode 100644 index 635b0f9f..00000000 --- a/src/lib/spadcolors.c.pamphlet +++ /dev/null @@ -1,618 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib spadcolors.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\eject -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -<<*>>= -<> - -#include "axiom-c-macros.h" -#include "spadcolors.h" - -#include -#include -#include -#include - -#include "spadcolors.H1" -#include "util.H1" - -#if 0 -int colors[100]; -#endif - -static unsigned long pixels[smoothConst+1]; - - -/* - * make sure you define a global variable like int *spadColors; in the main - * program - */ - -/* - * code taken from Foley and Van Dam "Fundamentals of Interactive Computer - * Graphics" - */ - - - -RGB -HSVtoRGB(HSV hsv) -{ - RGB rgb; - float h, f, p, q, t; - int i; - - rgb.r = 0.0; - rgb.g = 0.0; - rgb.b = 0.0; - if (hsv.s == 0.0) { - rgb.r = rgb.g = rgb.b = hsv.v; - return (rgb); - } - else { - if (hsv.h == 360.0) { - hsv.h = 0.0; - } - h = hsv.h / 60; - i = floor(h); - f = h - i; - p = hsv.v * (1 - hsv.s); - q = hsv.v * (1 - (hsv.s * f)); - t = hsv.v * (1 - (hsv.s * (1 - f))); - switch (i) { - case 0: - rgb.r = hsv.v; - rgb.g = t; - rgb.b = p; - break; - case 1: - rgb.r = q; - rgb.g = hsv.v; - rgb.b = p; - break; - case 2: - rgb.r = p; - rgb.g = hsv.v; - rgb.b = t; - break; - case 3: - rgb.r = p; - rgb.g = q; - rgb.b = hsv.v; - break; - case 4: - rgb.r = t; - rgb.g = p; - rgb.b = hsv.v; - break; - case 5: - rgb.r = hsv.v; - rgb.g = p; - rgb.b = q; - break; - } - return (rgb); - } -} - -float -value(float n1, float n2, float hue) -{ - float v; - - if (hue > 360.0) - hue -= 360.0; - if (hue < 0.0) - hue += 360.0; - if (hue < 60.0) { - v = n1 + (n2 - n1) * hue / 60.0; - } - else { - if (hue < 180.0) - v = n2; - else { - if (hue < 240.0) - v = n1 + (n2 - n1) * (240.0 - hue) / 60.0; - else - v = n1; - } - } - return (v); -} - - - -RGB -HLStoRGB(HLS hls) -{ - RGB rgb; - float m1, m2; - - if (hls.l <= 0.5) { - m2 = hls.l * (1.0 + hls.s); - } - else { - m2 = hls.l + hls.s - hls.l * hls.s; - } - m1 = 2.0 * hls.l - m2; - rgb.r = value(m1, m2, hls.h + 120.0); - rgb.g = value(m1, m2, hls.h); - rgb.b = value(m1, m2, hls.h - 120.0); - - return (rgb); -} - - -/****************************************************** - * int makeColors(dsply,scrn,colorMap,total_Shades) * - * * - * This routine tries to allocate an adequate color * - * map to be used by all the AXIOM applications * - * that are to be run under X Windows that use * - * colors that may be user-definable (e.g. viewports, * - * HyperTeX, etc). All these application should call * - * this routine and then access the colors with the * - * the returned color map. * - * For example, the following creates the map and * - * then sets the foreground color for a GC: * - * * - * i = makeColors(d,s,&cmap,&spadColors,&ts); * - * XSetForegroundColor(d,gc,spadColors[3]); * - * * - * where * - * spadColors is of type (unsigned long *) * - * i (the return value) is the total number of colors * - * allocated. * - * ts is the total number of shades for each hue * - * * - * KF 6/14/90 (modification) * - * makeColors creates color table once only. * - * hiya is of type static. * - ******************************************************/ - -int -makeColors(Display *dsply, int scrn, Colormap *colorMap, - unsigned long **colorIndex, int *total_Shades) -{ - - int h, s; - static unsigned long *hiya; /* keep colortable around for next time */ - HSV hsv; - RGB rgb; - XColor color; - int okay = yes; /* is true (1) so long as XAllocColor is - * working ok. if 0, then we ran out of room - * on the color table. */ - int colorNum; - - /* shade5 definition */ - - static float saturations[5] = {0.90, 0.80, 0.74, 0.50, 0.18}; - static float values[5] = {0.38, 0.58, 0.75, 0.88, 0.94}; - - /* static float values[5] = {0.34, 0.52, 0.80, 0.88, 0.94}; */ - - /* fprintf(stderr,"makeColors called\n");*/ - - /* printf("making new colors....\n"); */ - *total_Shades = totalShadesConst; - - /* space for color table */ - hiya = (unsigned long *) saymem("spadcolors30.c", totalHuesConst * (*total_Shades) + 2, sizeof(unsigned long)); - *colorIndex = hiya; - - for (h = 0, colorNum = 0; okay && h < 60; h += (hueStep - 6)) { - for (s = 0; okay && s < *total_Shades; s++) { - hsv.h = h; - hsv.s = saturations[s]; - hsv.v = values[s]; - rgb = HSVtoRGB(hsv); - color.red = rgb.r *((1<<16)-1); - color.green = rgb.g *((1<<16)-1); - color.blue = rgb.b *((1<<16)-1); - color.flags = DoRed | DoGreen | DoBlue; - /* - fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); - fprintf(stderr,"%d\t%d\t%d\n",color.red,color.green,color.blue); - */ - if ((okay = XAllocColor(dsply, *colorMap, &color))) - hiya[colorNum++] = color.pixel; /* hiya points to table */ - } /* for s */ - } /* for h */ - for (h = 60; okay && h < 180; h += 20) { - for (s = 0; okay && s < *total_Shades; s++) { - hsv.h = h; - hsv.s = saturations[s]; - hsv.v = values[s]; - rgb = HSVtoRGB(hsv); - - color.red = rgb.r *((1<<16)-1); - color.green = rgb.g *((1<<16)-1); - color.blue = rgb.b *((1<<16)-1); - color.flags = DoRed | DoGreen | DoBlue; - /* - fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); - fprintf(stderr,"%d\t%d\t%d\n",color.red,color.green,color.blue); - */ - - if ((okay = XAllocColor(dsply, *colorMap, &color))) - hiya[colorNum++] = color.pixel; - } - } - - for (h = 180; okay && h <= 300; h += hueStep) { - for (s = 0; okay && s < *total_Shades; s++) { - hsv.h = h; - hsv.s = saturations[s]; - hsv.v = values[s]; - rgb = HSVtoRGB(hsv); - - color.red = rgb.r *((1<<16)-1); - color.green = rgb.g *((1<<16)-1); - color.blue = rgb.b *((1<<16)-1); - color.flags = DoRed | DoGreen | DoBlue; - /* - fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); - fprintf(stderr,"%d\t%d\t%d\n",color.red,color.green,color.blue); - */ - if ((okay = XAllocColor(dsply, *colorMap, &color))) - hiya[colorNum++] = color.pixel; - } - } - - hiya[colorNum++] = BlackPixel(dsply, scrn); - hiya[colorNum++] = WhitePixel(dsply, scrn); - - if (colorNum < (totalShadesConst * totalHuesConst + 2)) { - free(*colorIndex); - fprintf(stderr, - " > Warning: cannot allocate all the necessary colors - switching to monochrome mode\n"); - *colorIndex = (unsigned long *) saymem("while allocating the colormap for AXIOM ", 2, sizeof(unsigned long)); - (*colorIndex)[0] = BlackPixel(dsply, scrn); - (*colorIndex)[1] = WhitePixel(dsply, scrn); - return (-1); - } - - return (colorNum); -} - -#ifdef OLD -/*********************************************************************** - KF 6/14/90 - INPUT: display dsply, screen scrn - OUTPUT: a pointer to the permutation color vector (permIndex) - PURPOSE: when called for the first time, this procedure creates a - permutation vector of the color table spadColor. It - returns the pointer to this vector for subsequent calls. - -***********************************************************************/ - -int -makePermVector(Display *dsply, int scrn, unsigned long **permIndex) -{ - static int firstTime = yes; - unsigned long *spadColorsToo; - static unsigned long *pIndex; - Colormap cmap; - int num_colors; - int i, ts; - - if (firstTime) { - - /* initialization */ - - cmap = DefaultColormap(dsply, scrn); /* what are other cmaps?? */ - pIndex = (unsigned long *) saymem("makePermVector", Colorcells, sizeof(unsigned long)); - - /* get spadColors table */ - - if ((num_colors = makeColors(dsply, scrn, &cmap, &spadColorsToo, &ts)) < 0) { - printf("num_colors < 0!!\n"); - exit(-1); - } - - /* initialize unused slots in permutation vector */ - - for (i = 0; i < spadColorsToo[0]; i++) - pIndex[i] = 0; - for (i = num_colors; i < Colorcells; i++) - pIndex[i] = 0; - - /* make permutation vector */ - - for (i = 0; i < num_colors; i++) - pIndex[spadColorsToo[i]] = i; - - firstTime = no; - } - - *permIndex = pIndex; - return (Colorcells); -} - -#endif - -/****************************************************** - * int makeNewColorMap(dsply,colorMap,smoothHue) * - * * - * This routine tries to allocate an adequate color * - * map to be used by the AXIOM smooth shading * - * application that is to be run under X Windows. * - * The colors are allocated from available space in * - * the colorMap and returned in the array pixels. * - * The size of the array is determined by smoothConst * - * which is the number of shades desired. The colors * - * returned are variations in lightness of the hue * - * smoothHue indicated on the control panel Colormap. * - * * - * If smoothConst colors can be allocated the value * - * 1 is returned, otherwise returns 0 * - * * - ******************************************************/ - - -int -makeNewColorMap(Display *dsply, Colormap colorMap, int smoothHue) - -{ - - int count, i; - float lightness; - RGB rgb; - XColor xcolor; - HLS hls; - - count = 0; - for (i = 0; i < (smoothConst + 1); i++) { /* i = 0 .. smoothConst */ - lightness = (float) (i) / (float) (smoothConst); /* lightnes = 0.0 .. 1.0 */ - hls.h = (float) smoothHue; - hls.l = lightness; - hls.s = saturation; - rgb = HLStoRGB(hls); - - xcolor.red = rgb.r *((1<<16)-1); - xcolor.green = rgb.g *((1<<16)-1); - xcolor.blue = rgb.b *((1<<16)-1); - xcolor.flags = DoRed | DoGreen | DoBlue; - /* - fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); - fprintf(stderr,"%d\t%d\t%d\n",xcolor.red,xcolor.green,xcolor.blue); - */ - if (XAllocColor(dsply, colorMap, &xcolor)) { - pixels[count] = xcolor.pixel; - count++; - } - } - /* count says how many succeeded */ - if (count != (smoothConst+1) ) { - - /* we have failed to get all of them - free the ones we got */ - - FreePixels(dsply,colorMap,count); - return (0); - } - return (1); -} - - - -/****************************************************** - * unsigned long XPixelColor(num) * - * * - * XPixelColor is a straight forward function that * - * merely returns the XColor value desired within * - * the pixels array. For smooth shading, given an * - * intensity from 0..1, scaling by the number of * - * values in the array will return the location in * - * pixels[] of the desired color for that intensity. * - * * - ******************************************************/ - -unsigned long -XPixelColor(int num) -{ - if (num < 0) - num = 0; - return (pixels[num]); -} - - -/****************************************************** - * FreePixels(dsply,colorMap,num) * - * * - * FreePixels is a call to XFreeColors which frees * - * previously allocated colors for the indicated * - * colorMap. If it cannot free the number of colors * - * given by num a BadAccess error will crash the * - * viewport process. This should ONLY be used if * - * it can be guaranteed that there will be num colors * - * to free in colorMap. return 0 == success * - * * - ******************************************************/ - - -void -FreePixels(Display *dsply, Colormap colorMap, int num) -{ - - XFreeColors(dsply, colorMap, pixels, num, 0); -} - - - -/****************************************************** - * int AllocCells(dsply,colorMap,smoothHue) * - * * - * Use either makeNewColormap() OR AllocCells(). * - * This routine tries to allocate an adequate color * - * map to be used by the AXIOM smooth shading * - * application that is to be run under X Windows. * - * The colors are allocated from available space in * - * the colorMap and returned in the array pixels. * - * The size of the array is determined by smoothConst * - * which is the number of shades desired. The colors * - * returned are variations in lightness of the hue * - * smoothHue indicated on the control panel Colormap. * - * * - * It is different from makeNewColormap() in that * - * the cells are read/write, and if it cannot alloc * - * all the colors desired it doesn't allocate any. * - * * - ******************************************************/ - - -int -AllocCells(Display *dsply, Colormap colorMap, int smoothHue) -@ -This routine used to have the following code block. However this -code block makes no sense. To see why you need to know that an -XColor object looks like: -\begin{verbatim} -/* - * Data structure used by color operations - */ -typedef struct { - unsigned long pixel; - unsigned short red, green, blue; - char flags; /* do_red, do_green, do_blue */ - char pad; -} XColor; -\end{verbatim} -This routine used to set the values of all of the elements of the XColor struct -except [[pixel]]. This is usually done to specify a desired color in RGB -values. To try to get a pixel value close to that color you call XAllocColor. -This routine sets up the desired color values but it never asks for the pixel -(which is really an index into the colormap of the nearest color) value that -corresponds to the desired color. In fact it uses pixel without ever giving -it a value. I've rewritten that code. -\begin{verbatim} -{ - unsigned long plane_masks[1]; - int i, count; - float lightness; - RGB rgb; - XColor xcolor; - HLS hls; - - count = 0; - for (i = 0; i < (smoothConst + 1); i++) { - lightness = (float) (i) / (float) (smoothConst); - hls.h = (float) smoothHue; - hls.l = lightness; - hls.s = saturation; - rgb = HLStoRGB(hls); - xcolor.red = rgb.r *((1@<<16)-1); - xcolor.green = rgb.g *((1@<<16)-1); - xcolor.blue = rgb.b *((1@<<16)-1); - xcolor.flags = DoRed | DoGreen | DoBlue; - /* - fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); - fprintf(stderr,"%d\t%d\t%d\n",xcolor.red,xcolor.green,xcolor.blue); - */ - pixels[i] = xcolor.pixel; - count++; - } - if (XAllocColorCells(dsply, colorMap, False, - plane_masks, 0, pixels, smoothConst + 1)) { - return (smoothConst + 1); - } - else { - return (0); - } -} -\end{verbatim} -<<*>>= -{ - unsigned long plane_masks[1]; - int i, count; - float lightness; - RGB rgb; - XColor xcolor; - HLS hls; - - count = 0; - for (i = 0; i < (smoothConst + 1); i++) { - lightness = (float) (i) / (float) (smoothConst); - hls.h = (float) smoothHue; - hls.l = lightness; - hls.s = saturation; - rgb = HLStoRGB(hls); - xcolor.red = rgb.r *((1<<16)-1); - xcolor.green = rgb.g *((1<<16)-1); - xcolor.blue = rgb.b *((1<<16)-1); - xcolor.flags = DoRed | DoGreen | DoBlue; - /* - fprintf(stderr,"%f\t%f\t%f\n",rgb.r,rgb.g,rgb.b); - fprintf(stderr,"%d\t%d\t%d\n",xcolor.red,xcolor.green,xcolor.blue); - */ -@ -Here I've modified the code to actually as for the pixel (colormap index) that -most closely matches our requested RGB values. -<<*>>= - if (XAllocColor(dsply, colorMap, &xcolor)) { - pixels[count] = xcolor.pixel; - count++; - } - } - /* count says how many succeeded */ - if (count != (smoothConst+1) ) { - /* we have failed to get all of them - free the ones we got */ - FreePixels(dsply,colorMap,count); - return (0); - } - if (XAllocColorCells(dsply, colorMap, False, - plane_masks, 0, pixels, smoothConst + 1)) { - return (smoothConst + 1); - } - else { - return (0); - } -} -@ -\eject -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/util.c b/src/lib/util.c new file mode 100644 index 00000000..3d34c275 --- /dev/null +++ b/src/lib/util.c @@ -0,0 +1,162 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "axiom-c-macros.h" + +#include +#if defined(MACOSXplatform) +#include "/usr/include/unistd.h" +#else +#include +#endif +#include +#include +#include +#include +#include +#include "view.h" + + +#include "util.H1" + + + + +int +checker(int code, int lineNumber, char *errorStr) +{ + if (code < 0) { + fprintf(stderr, "Error occured during %s\n", errorStr); + fprintf(stderr, "Error code of %d\n", errno); + fprintf(stderr, "Error in line number %d of process %d\n", lineNumber, getpid()); + perror(""); + } + return (code); +} + + + + +char * +getmemWithLine(int nbytes, char *str, int lineNum) +{ + char *p; + + p = (char *) malloc(nbytes); + if (!p) { + fprintf(stderr, "getmem: Could not get %d bytes for %s at line %d\n", nbytes, str, lineNum); + exit(99); + } + return p; +} + + +char * +saymemWithLine(char *str, int num, int size, int lineNum) +{ + char *p; + + p = getmemWithLine(num * size, str, lineNum); + return p; + +} + + +void +#ifdef _NO_PROTO +myfree(p, size) + void *p; + int size; +#else +myfree(void *p, int size) +#endif +{ + free(p); +} + + + + +XPoint +getWindowPositionXY(Display *display, Window w) +{ + XPoint position; + Window rootW, parentW, *childrenWs, tmpW; + unsigned int nChildren; + XWindowAttributes windowAttrib; + int screen, tmp = 1; + + screen = DefaultScreen(display); + tmpW = w; + while (tmp) { + XQueryTree(display, tmpW, &rootW, &parentW, &childrenWs, &nChildren); + XFree((char *)childrenWs); + if (parentW == RootWindow(display, screen)) + tmp = 0; + else + tmpW = parentW; + } + XGetWindowAttributes(display, tmpW, &windowAttrib); + position.x = (short) windowAttrib.x; + position.y = (short) windowAttrib.y; + + return (position); +} + + + +XPoint +getWindowSizeXY(Display *display,Window w) +{ + XPoint size; + Window rootW, parentW, *childrenWs, tmpW; + unsigned int nChildren; + XWindowAttributes windowAttrib; + int screen, tmp = 1; + + screen = DefaultScreen(display); + tmpW = w; + while (tmp) { + XQueryTree(display, tmpW, &rootW, &parentW, &childrenWs, &nChildren); + XFree((char *)childrenWs); + if (parentW == RootWindow(display, screen)) + tmp = 0; + else + tmpW = parentW; + } + XGetWindowAttributes(display, tmpW, &windowAttrib); + size.x = (short) windowAttrib.width; + size.y = (short) windowAttrib.height; + + return (size); +} diff --git a/src/lib/util.c.pamphlet b/src/lib/util.c.pamphlet deleted file mode 100644 index f4ec3a6e..00000000 --- a/src/lib/util.c.pamphlet +++ /dev/null @@ -1,192 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib util.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\newpage -<<*>>= -<> - -#include "axiom-c-macros.h" - -#include -@ -The MACOSX platform is broken because no matter what you do it seems to -include files from [[/usr/include/sys]] ahead of [[/usr/include]]. On linux -systems these files include themselves which causes an infinite regression -of includes that fails. GCC gracefully steps over that problem but the -build fails anyway. On MACOSX the [[/usr/include/sys]] versions -of files are badly broken with respect to the [[/usr/include]] versions. -<<*>>= -#if defined(MACOSXplatform) -#include "/usr/include/unistd.h" -#else -#include -#endif -#include -#include -#include -#include -#include -#include "view.h" - - -#include "util.H1" - - - - -int -checker(int code, int lineNumber, char *errorStr) -{ - if (code < 0) { - fprintf(stderr, "Error occured during %s\n", errorStr); - fprintf(stderr, "Error code of %d\n", errno); - fprintf(stderr, "Error in line number %d of process %d\n", lineNumber, getpid()); - perror(""); - } - return (code); -} - - - - -char * -getmemWithLine(int nbytes, char *str, int lineNum) -{ - char *p; - - p = (char *) malloc(nbytes); - if (!p) { - fprintf(stderr, "getmem: Could not get %d bytes for %s at line %d\n", nbytes, str, lineNum); - exit(99); - } - return p; -} - - -char * -saymemWithLine(char *str, int num, int size, int lineNum) -{ - char *p; - - p = getmemWithLine(num * size, str, lineNum); - return p; - -} - - -void -#ifdef _NO_PROTO -myfree(p, size) - void *p; - int size; -#else -myfree(void *p, int size) -#endif -{ - free(p); -} - - - - -XPoint -getWindowPositionXY(Display *display, Window w) -{ - XPoint position; - Window rootW, parentW, *childrenWs, tmpW; - unsigned int nChildren; - XWindowAttributes windowAttrib; - int screen, tmp = 1; - - screen = DefaultScreen(display); - tmpW = w; - while (tmp) { - XQueryTree(display, tmpW, &rootW, &parentW, &childrenWs, &nChildren); - XFree((char *)childrenWs); - if (parentW == RootWindow(display, screen)) - tmp = 0; - else - tmpW = parentW; - } - XGetWindowAttributes(display, tmpW, &windowAttrib); - position.x = (short) windowAttrib.x; - position.y = (short) windowAttrib.y; - - return (position); -} - - - -XPoint -getWindowSizeXY(Display *display,Window w) -{ - XPoint size; - Window rootW, parentW, *childrenWs, tmpW; - unsigned int nChildren; - XWindowAttributes windowAttrib; - int screen, tmp = 1; - - screen = DefaultScreen(display); - tmpW = w; - while (tmp) { - XQueryTree(display, tmpW, &rootW, &parentW, &childrenWs, &nChildren); - XFree((char *)childrenWs); - if (parentW == RootWindow(display, screen)) - tmp = 0; - else - tmpW = parentW; - } - XGetWindowAttributes(display, tmpW, &windowAttrib); - size.x = (short) windowAttrib.width; - size.y = (short) windowAttrib.height; - - return (size); -} -@ -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -\newpage -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} diff --git a/src/lib/wct.c b/src/lib/wct.c new file mode 100644 index 00000000..58b4e308 --- /dev/null +++ b/src/lib/wct.c @@ -0,0 +1,738 @@ +/* + Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS + IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A + PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/* + * Word completion. + * + * + * Word completion is driven from a list of completion tables. Each table + * contains a list of words. + * + */ + +#include "axiom-c-macros.h" + +#include +#include +#if defined(MACOSXplatform) +#include "/usr/include/unistd.h" +#else +#include +#endif +#include +#include +#if defined(MACOSXplatform) +#include "/usr/include/time.h" +#else +#include +#endif +#include +#include +#include + +/* #define PINFO *//* A flag to suppress printing of the file info */ + +#define WCT /* A flag needed because ctype.h stole some + * of my constants */ +#include "edible.h" + +#define MAX_PREFIX 1024 +#define strneql(a,b,n) (*(a) == *(b) && !strncmp((a),(b),(n))) +#define Delimiter(c) (! isalnum(c) && c != '%' && c != '!' && c != '?' && c != '_') + + +#include "wct.H1" +#include "prt.H1" +#include "edin.H1" + + + +static Wct *pwct = 0; +static Wix *pwix; +static Wix curr_wix; +static char curr_prefix[MAX_PREFIX]; +static Wct *pHeadwct; + +time_t +ftime(char *path) +{ + int rc; + struct stat stbuf; + + rc = stat(path, &stbuf); + if (rc == -1) + fatal("Cannot deterimine status of %s.", path); + + return stbuf.st_mtime; +} + +off_t +fsize(char *path) +{ + int rc; + struct stat stbuf; + + rc = stat(path, &stbuf); + if (rc == -1) + fatal("Cannot deterimine status of %s.", path); + + return stbuf.st_size; +} + + +/* + * Scan a word completion table for a particular word. + */ + + +Wix * +scanWct(Wct *pwct, char *prefix) +{ + long fmod; + int preflen, i, wc; + char **wv; + + preflen = strlen(prefix); + strncpy(curr_prefix, prefix, MAX_PREFIX); + + pHeadwct = pwct; + curr_wix.pwct = 0; + curr_wix.word = 0; + + for (; pwct; pwct = pwct->next) { + curr_wix.pwct = pwct; + + + + fmod = ftime(pwct->fname); + if (fmod > pwct->ftime) + reintern1Wct(pwct); + + wv = pwct->wordv; + wc = pwct->wordc; + for (i = 0; i < wc; i++) { + curr_wix.word = i; + if (strneql(wv[i], prefix, preflen)) + return &curr_wix; + } + } + return 0; +} + +Wix * +rescanWct(void) +{ + Wct *pwct, *start_pwct; + int preflen, start_word, i, wc; + char **wv, *prefix; + + start_pwct = curr_wix.pwct; + start_word = curr_wix.word; + + if (!start_pwct) return(0); + prefix = curr_prefix; + preflen = strlen(prefix); + + /* + * Finish the current structure. + */ + + pwct = start_pwct; + + curr_wix.pwct = pwct; + wv = pwct->wordv; + wc = pwct->wordc; + for (i = start_word + 1; i < wc; i++) { + curr_wix.word = i; + if (strneql(wv[i], prefix, preflen)) + return &curr_wix; + } + + /* + * Finish to the end of the list, doing whole structures. + */ + for (pwct = pwct->next; pwct; pwct = pwct->next) { + curr_wix.pwct = pwct; + + wv = pwct->wordv; + wc = pwct->wordc; + for (i = 0; i < wc; i++) { + curr_wix.word = i; + if (strneql(wv[i], prefix, preflen)) + return &curr_wix; + } + } + + /* + * Restart at beginning, doing whole structures. + */ + for (pwct = pHeadwct; pwct != start_pwct; pwct = pwct->next) { + curr_wix.pwct = pwct; + + wv = pwct->wordv; + wc = pwct->wordc; + for (i = 0; i < wc; i++) { + curr_wix.word = i; + if (strneql(wv[i], prefix, preflen)) + return &curr_wix; + } + } + + /* + * Do beginning half of the start structure. + */ + curr_wix.pwct = pwct; + wv = pwct->wordv; + wc = pwct->wordc; + for (i = 0; i <= start_word; i++) { + curr_wix.word = i; + if (strneql(wv[i], prefix, preflen)) + return &curr_wix; + } + + /* Not found? */ + return 0; +} + +/* + * Summarize a table. + */ +void +skimWct(Wct *pwct) +{ + while (pwct) { +#ifdef PINFO + skim1Wct(pwct); +#endif + pwct = pwct->next; + } +} + +void +skim1Wct(Wct *pwct) +{ +#define NHEAD 13 +#define NTAIL 7 + + int cc; + + printf("%-10s", pwct->fname); + printTime((long *)&(pwct->ftime)); + cc = skimString(pwct->fimage, pwct->fsize, NHEAD, NTAIL); + printf("%s", " " + (cc - (NHEAD + NTAIL))); + printf(" [%d w, %ld c]", pwct->wordc, (long)(pwct->fsize)); + printf("\n"); + +#ifdef SHOW_WORDS + { + int i; + char **wv; + + for (i = 1, wv = pwct->wordv; *wv; i++, wv++) { + printf("%5d: %s\n", i, *wv); + } + } +#endif +} + +void +printTime(long *clock) +{ + struct tm *tm; + + tm = localtime((time_t *)clock); + printf("%.2d/%.2d/%.2d %.2d:%.2d:%.2d ", + tm->tm_year, tm->tm_mon + 1, tm->tm_mday, + tm->tm_hour, tm->tm_min, tm->tm_sec); +} + +int +skimString(char *s, int slen,int nhead,int ntail) +{ + int spos, tlen, i, cc; + + cc = printf("\""); + for (spos = 0; spos < slen && cc <= nhead; spos++) + cc += prChar(s[spos]); + + /* Assume same tail has the same multi-character format ratio. */ + tlen = ntail * ((1.0 * spos) / nhead); + + if (spos + tlen >= slen) + for (; spos < slen; spos++) + cc += prChar(s[spos]); + else { + cc += printf("\"...\""); + for (i = slen - tlen; i < slen; i++) + cc += prChar(s[i]); + } + cc += printf("\""); + return cc; +} + +int +prChar(int c) +{ + if (c == '\n') + return printf("\\n"); + if (c == '\t') + return printf("\\t"); + if (c == '\b') + return printf("\\b"); + if (c == '"') + return printf("\\\""); + if (iscntrl(c)) + return printf("^%c", (c + 0100) % 0200); + if (isascii(c)) + return printf("%c", c); + + return printf("\\%d", c); +} + +Wct * +reread1Wct(Wct *pwct) +{ + int fd, rc; + + /* Check information about the file. */ + pwct->fsize = fsize(pwct->fname); + pwct->ftime = ftime(pwct->fname); + + /* Allocate space for file image */ + if (pwct->fimage) + free(pwct->fimage); + pwct->fimage = (char *) malloc(pwct->fsize + 1); + if (pwct->fimage == 0) + sfatal("Cannot allocate new table."); + pwct->fimage[pwct->fsize] = 0; + + /* Read file into buffer. */ + fd = open(pwct->fname, O_RDONLY); + if (fd == -1) + fatal("Cannot read file %s.", pwct->fname); + rc = read(fd, pwct->fimage, pwct->fsize); + if (rc != pwct->fsize) + fatal("Did not read all of file %s.", pwct->fname); + + return pwct; +} + +Wct * +read1Wct(char *fname) +{ + Wct *pwct; + + /* Allocate a new link for this file. */ + pwct = (Wct *) malloc(sizeof(Wct)); + if (pwct == 0) + sfatal("Cannot allocate new table."); + + pwct->fname = fname; + pwct->wordc = 0; + pwct->wordv = 0; + pwct->fimage = 0; + pwct->next = 0; + + return reread1Wct(pwct); +} + +Wct * +nconcWct(Wct *pwct,Wct * qwct) +{ + Wct *p0 = pwct; + + if (!p0) + return qwct; + + while (pwct->next) + pwct = pwct->next; + pwct->next = qwct; + + return p0; +} + +void +sortWct(Wct *pwct) +{ + while (pwct) { + sort1Wct(pwct); + pwct = pwct->next; + } +} + +void +sort1Wct(Wct *pwct) +{ + qsort((char *) pwct->wordv, pwct->wordc, + sizeof(*(pwct->wordv)), mystrcmp); +} + +int +mystrcmp(const void *s1,const void * s2) +{ + return strcmp(*(char **)s1, *(char **)s2); +} + +/* + * Break wct struct into words. + */ + +void +burstWct(Wct *pwct) +{ + while (pwct) { + burst1Wct(pwct); + pwct = pwct->next; + } +} + +void +burst1Wct(Wct *pwct) +{ + char *s, **wv; + int i, j, inword = 0; + + + for (s = pwct->fimage, i = 0; i < pwct->fsize; s++, i++) { + if (isspace(*s) || iscntrl(*s)) { + *s = 0; + inword = 0; + } + else if (!inword) { + inword = 1; + pwct->wordc++; + } + } + + if (pwct->wordv) + free(pwct->wordv); + pwct->wordv = (char **) calloc(pwct->wordc + 1, sizeof(char *)); + if (!pwct->wordv) + fatal("Could not make word list for %s.", pwct->fname); + + s = pwct->fimage; + i = 0; + for (wv = pwct->wordv, j = 0; j < pwct->wordc; wv++, j++) { + while (i < pwct->fsize && !s[i]) + i++; + *wv = s + i; + while (i < pwct->fsize && s[i]) + i++; + } + *wv = 0; +} + +Wct * +intern1Wct(char *fname) +{ + Wct *pwct; + + pwct = read1Wct(fname); + burst1Wct(pwct); + return pwct; +} + +void +reintern1Wct(Wct *pwct) +{ + reread1Wct(pwct); + burst1Wct(pwct); +} + +void +sfatal(char *s) +{ + fatal("%s", s); +} + +void +fatal(char *fmt,char * s) +{ + static char fbuf[256]; + + sprintf(fbuf, fmt, s); + + perror(fbuf); + exit(1); +} + + + +/* load up the wct database */ +void +load_wct_file(char *fname) +{ + pwct = nconcWct(intern1Wct(fname), pwct); +} + +void +skim_wct(void) +{ + skimWct(pwct); +} + +/* + * This routine is called when a tab is hit. It simply takes the current + * buffer and tries to find a completion of the last word on the line in the + * data base. + */ + + +void +rescan_wct(void) +{ + int b = curr_pntr - 1; + int old_len; + int new_len; + int diff; + int i; + int ncs = 0; + + /* + * first thing I should do is find my way back to the beginning of the + * word + */ + while (b && !Delimiter(buff[b])) + b--; + if (Delimiter(buff[b])) + b++; + + old_len = curr_pntr - b; + + pwix = rescanWct(); + + if (!pwix) { + putchar(_BELL); + fflush(stdout); + } + else { + Wct *pwct = pwix->pwct; /* start replacing it */ + + new_len = strlen(pwct->wordv[pwix->word]); + if (new_len > old_len) { + + /* + * I have to just slide the characters forward a bit, stuff in + * the new characters, and then adjust curr_pntr + */ + diff = new_len - old_len; + if (curr_pntr != buff_pntr) { + forwardcopy(&buff[curr_pntr + diff], + &buff[curr_pntr], + buff_pntr - curr_pntr); + forwardflag_cpy(&buff_flag[curr_pntr + diff], + &buff_flag[curr_pntr], + buff_pntr - curr_pntr); + } + buff_pntr += diff; + ncs = curr_pntr + diff; + + /* Now insert the new word */ + for (i = 0; i < new_len; i++) + buff[b + i] = (pwct->wordv[pwix->word])[i]; + + /* move cursor to the beginning of the word */ + for (; curr_pntr != b; curr_pntr--) + putchar(_BKSPC); + + /** now print the characters on the rest of the line **/ + printbuff(curr_pntr, buff_pntr - curr_pntr); + + /* now move bcak the number of characters I want to */ + for (i = buff_pntr; i != ncs; i--) + putchar(_BKSPC); + + fflush(stdout); + + curr_pntr = ncs; + } + else if (new_len < old_len) { + /* this time I simply copy backwards and do the substituting */ + diff = old_len - new_len; + strncpy(&buff[curr_pntr - diff], + &buff[curr_pntr], + buff_pntr - curr_pntr); + flagncpy(&buff_flag[curr_pntr - diff], + &buff_flag[curr_pntr], + buff_pntr - curr_pntr); + buff_pntr -= diff; + ncs = curr_pntr - diff; + + /* Now insert the new word */ + for (i = 0; i < new_len; i++) + buff[b + i] = (pwct->wordv[pwix->word])[i]; + + /* move cursor to the beginning of the word */ + for (; curr_pntr != b; curr_pntr--) + putchar(_BKSPC); + + /** now print the characters on the rest of the line **/ + printbuff(b, buff_pntr - b); + + /* now blank out the characters out on the end of this line */ + for (i = 0; i < diff; i++) + myputchar(' '); + + /* now move back the number of characters I want to */ + for (i = buff_pntr + diff; i != ncs; i--) + putchar(_BKSPC); + + fflush(stdout); + + curr_pntr = ncs; + } + else { + diff = 0; + ncs = curr_pntr; + /* Now insert the new word */ + for (i = 0; i < new_len; i++) + buff[b + i] = (pwct->wordv[pwix->word])[i]; + + /* move cursor to the beginning of the word */ + for (; curr_pntr != b; curr_pntr--) + putchar(_BKSPC); + + /** now print the characters on the rest of the line **/ + printbuff(curr_pntr, buff_pntr - curr_pntr); + + /* now move back the number of characters I want to */ + for (i = buff_pntr; i != ncs; i--) + putchar(_BKSPC); + + fflush(stdout); + + curr_pntr = ncs; + } + } +} + +void +find_wct(void) +{ + + char search_buff[100]; + char *filler = search_buff; + int b = curr_pntr - 1; + int e = curr_pntr; + int ne = 0; + int st; + Wix *pwix; + int curr_len; + int new_len; + int diff; + int i; + + /* + * First thing I do is try and construct the string to be searched for. + * Basically I just start from the curr_pntr and search backward until I + * find a blank. Once I find a blank I copy forward until I get back to + * curr_pntr; + */ + if (!curr_pntr) { + putchar(_BELL); + return; + } + /* then get back to the first blank or back to the beginning */ + while (b && !Delimiter(buff[b])) + b--; + if (Delimiter(buff[b])) + b++; + + /* At the same time, let me find the end of the word */ + while (e < buff_pntr && !Delimiter(buff[e])) { + e++; + ne++; + } + + st = b; + curr_len = e - b; + + /* now simply copy the text forward */ + while (b < curr_pntr) + *filler++ = buff[b++]; + + *filler = '\0'; + + pwix = scanWct(pwct, search_buff); + + /* + * else pwix = rescanWct(); + */ + + if (!pwix) { + putchar(_BELL); + fflush(stdout); + } + else { + Wct *pwct = pwix->pwct; + + /* + * printf("Found %s in file %s\n", pwct->wordv[pwix->word], + * pwct->fname); + */ + /* copy them buffer into where it should be */ + new_len = strlen(pwct->wordv[pwix->word]); + diff = new_len - curr_len; + if (curr_pntr != buff_pntr) { + forwardcopy(&buff[curr_pntr + diff], + &buff[curr_pntr], + buff_pntr - curr_pntr); + forwardflag_cpy(&buff_flag[curr_pntr + diff], + &buff_flag[curr_pntr], + buff_pntr - curr_pntr); + } + buff_pntr += diff; + + + /* Now insert the new characters */ + for (i = new_len - diff; i < new_len; i++) + buff[st + i] = (pwct->wordv[pwix->word])[i]; + + /* Now move the cursor forward to the end of the word */ + for (i = 0; i < diff; i++) + putchar(buff[curr_pntr++]); + + /** now print the characters on the rest of the line **/ + printbuff(curr_pntr, buff_pntr - curr_pntr); + + /* now move bcak the number of characters I want to */ + for (i = buff_pntr; i != e + diff; i--) + putchar(_BKSPC); + + fflush(stdout); + + curr_pntr = diff + e; + + } + + +} diff --git a/src/lib/wct.c.pamphlet b/src/lib/wct.c.pamphlet deleted file mode 100644 index 0ceff558..00000000 --- a/src/lib/wct.c.pamphlet +++ /dev/null @@ -1,768 +0,0 @@ -\documentclass{article} -\usepackage{axiom} -\begin{document} -\title{\$SPAD/src/lib wct.c} -\author{The Axiom Team} -\maketitle -\begin{abstract} -\end{abstract} -\eject -\tableofcontents -\newpage -<<*>>= -<> -/* - * Word completion. - * - * - * Word completion is driven from a list of completion tables. Each table - * contains a list of words. - * - */ - -#include "axiom-c-macros.h" - -#include -#include -@ -The MACOSX platform is broken because no matter what you do it seems to -include files from [[/usr/include/sys]] ahead of [[/usr/include]]. On linux -systems these files include themselves which causes an infinite regression -of includes that fails. GCC gracefully steps over that problem but the -build fails anyway. On MACOSX the [[/usr/include/sys]] versions -of files are badly broken with respect to the [[/usr/include]] versions. -<<*>>= -#if defined(MACOSXplatform) -#include "/usr/include/unistd.h" -#else -#include -#endif -#include -#include -#if defined(MACOSXplatform) -#include "/usr/include/time.h" -#else -#include -#endif -#include -#include -#include - -/* #define PINFO *//* A flag to suppress printing of the file info */ - -#define WCT /* A flag needed because ctype.h stole some - * of my constants */ -#include "edible.h" - -#define MAX_PREFIX 1024 -#define strneql(a,b,n) (*(a) == *(b) && !strncmp((a),(b),(n))) -#define Delimiter(c) (! isalnum(c) && c != '%' && c != '!' && c != '?' && c != '_') - - -#include "wct.H1" -#include "prt.H1" -#include "edin.H1" - - - -static Wct *pwct = 0; -static Wix *pwix; -static Wix curr_wix; -static char curr_prefix[MAX_PREFIX]; -static Wct *pHeadwct; - -time_t -ftime(char *path) -{ - int rc; - struct stat stbuf; - - rc = stat(path, &stbuf); - if (rc == -1) - fatal("Cannot deterimine status of %s.", path); - - return stbuf.st_mtime; -} - -off_t -fsize(char *path) -{ - int rc; - struct stat stbuf; - - rc = stat(path, &stbuf); - if (rc == -1) - fatal("Cannot deterimine status of %s.", path); - - return stbuf.st_size; -} - - -/* - * Scan a word completion table for a particular word. - */ - - -Wix * -scanWct(Wct *pwct, char *prefix) -{ - long fmod; - int preflen, i, wc; - char **wv; - - preflen = strlen(prefix); - strncpy(curr_prefix, prefix, MAX_PREFIX); - - pHeadwct = pwct; - curr_wix.pwct = 0; - curr_wix.word = 0; - - for (; pwct; pwct = pwct->next) { - curr_wix.pwct = pwct; - - - - fmod = ftime(pwct->fname); - if (fmod > pwct->ftime) - reintern1Wct(pwct); - - wv = pwct->wordv; - wc = pwct->wordc; - for (i = 0; i < wc; i++) { - curr_wix.word = i; - if (strneql(wv[i], prefix, preflen)) - return &curr_wix; - } - } - return 0; -} - -Wix * -rescanWct(void) -{ - Wct *pwct, *start_pwct; - int preflen, start_word, i, wc; - char **wv, *prefix; - - start_pwct = curr_wix.pwct; - start_word = curr_wix.word; - - if (!start_pwct) return(0); - prefix = curr_prefix; - preflen = strlen(prefix); - - /* - * Finish the current structure. - */ - - pwct = start_pwct; - - curr_wix.pwct = pwct; - wv = pwct->wordv; - wc = pwct->wordc; - for (i = start_word + 1; i < wc; i++) { - curr_wix.word = i; - if (strneql(wv[i], prefix, preflen)) - return &curr_wix; - } - - /* - * Finish to the end of the list, doing whole structures. - */ - for (pwct = pwct->next; pwct; pwct = pwct->next) { - curr_wix.pwct = pwct; - - wv = pwct->wordv; - wc = pwct->wordc; - for (i = 0; i < wc; i++) { - curr_wix.word = i; - if (strneql(wv[i], prefix, preflen)) - return &curr_wix; - } - } - - /* - * Restart at beginning, doing whole structures. - */ - for (pwct = pHeadwct; pwct != start_pwct; pwct = pwct->next) { - curr_wix.pwct = pwct; - - wv = pwct->wordv; - wc = pwct->wordc; - for (i = 0; i < wc; i++) { - curr_wix.word = i; - if (strneql(wv[i], prefix, preflen)) - return &curr_wix; - } - } - - /* - * Do beginning half of the start structure. - */ - curr_wix.pwct = pwct; - wv = pwct->wordv; - wc = pwct->wordc; - for (i = 0; i <= start_word; i++) { - curr_wix.word = i; - if (strneql(wv[i], prefix, preflen)) - return &curr_wix; - } - - /* Not found? */ - return 0; -} - -/* - * Summarize a table. - */ -void -skimWct(Wct *pwct) -{ - while (pwct) { -#ifdef PINFO - skim1Wct(pwct); -#endif - pwct = pwct->next; - } -} - -void -skim1Wct(Wct *pwct) -{ -#define NHEAD 13 -#define NTAIL 7 - - int cc; - - printf("%-10s", pwct->fname); - printTime((long *)&(pwct->ftime)); - cc = skimString(pwct->fimage, pwct->fsize, NHEAD, NTAIL); - printf("%s", " " + (cc - (NHEAD + NTAIL))); - printf(" [%d w, %ld c]", pwct->wordc, (long)(pwct->fsize)); - printf("\n"); - -#ifdef SHOW_WORDS - { - int i; - char **wv; - - for (i = 1, wv = pwct->wordv; *wv; i++, wv++) { - printf("%5d: %s\n", i, *wv); - } - } -#endif -} - -void -printTime(long *clock) -{ - struct tm *tm; - - tm = localtime((time_t *)clock); - printf("%.2d/%.2d/%.2d %.2d:%.2d:%.2d ", - tm->tm_year, tm->tm_mon + 1, tm->tm_mday, - tm->tm_hour, tm->tm_min, tm->tm_sec); -} - -int -skimString(char *s, int slen,int nhead,int ntail) -{ - int spos, tlen, i, cc; - - cc = printf("\""); - for (spos = 0; spos < slen && cc <= nhead; spos++) - cc += prChar(s[spos]); - - /* Assume same tail has the same multi-character format ratio. */ - tlen = ntail * ((1.0 * spos) / nhead); - - if (spos + tlen >= slen) - for (; spos < slen; spos++) - cc += prChar(s[spos]); - else { - cc += printf("\"...\""); - for (i = slen - tlen; i < slen; i++) - cc += prChar(s[i]); - } - cc += printf("\""); - return cc; -} - -int -prChar(int c) -{ - if (c == '\n') - return printf("\\n"); - if (c == '\t') - return printf("\\t"); - if (c == '\b') - return printf("\\b"); - if (c == '"') - return printf("\\\""); - if (iscntrl(c)) - return printf("^%c", (c + 0100) % 0200); - if (isascii(c)) - return printf("%c", c); - - return printf("\\%d", c); -} - -Wct * -reread1Wct(Wct *pwct) -{ - int fd, rc; - - /* Check information about the file. */ - pwct->fsize = fsize(pwct->fname); - pwct->ftime = ftime(pwct->fname); - - /* Allocate space for file image */ - if (pwct->fimage) - free(pwct->fimage); - pwct->fimage = (char *) malloc(pwct->fsize + 1); - if (pwct->fimage == 0) - sfatal("Cannot allocate new table."); - pwct->fimage[pwct->fsize] = 0; - - /* Read file into buffer. */ - fd = open(pwct->fname, O_RDONLY); - if (fd == -1) - fatal("Cannot read file %s.", pwct->fname); - rc = read(fd, pwct->fimage, pwct->fsize); - if (rc != pwct->fsize) - fatal("Did not read all of file %s.", pwct->fname); - - return pwct; -} - -Wct * -read1Wct(char *fname) -{ - Wct *pwct; - - /* Allocate a new link for this file. */ - pwct = (Wct *) malloc(sizeof(Wct)); - if (pwct == 0) - sfatal("Cannot allocate new table."); - - pwct->fname = fname; - pwct->wordc = 0; - pwct->wordv = 0; - pwct->fimage = 0; - pwct->next = 0; - - return reread1Wct(pwct); -} - -Wct * -nconcWct(Wct *pwct,Wct * qwct) -{ - Wct *p0 = pwct; - - if (!p0) - return qwct; - - while (pwct->next) - pwct = pwct->next; - pwct->next = qwct; - - return p0; -} - -void -sortWct(Wct *pwct) -{ - while (pwct) { - sort1Wct(pwct); - pwct = pwct->next; - } -} - -void -sort1Wct(Wct *pwct) -{ - qsort((char *) pwct->wordv, pwct->wordc, - sizeof(*(pwct->wordv)), mystrcmp); -} - -int -mystrcmp(const void *s1,const void * s2) -{ - return strcmp(*(char **)s1, *(char **)s2); -} - -/* - * Break wct struct into words. - */ - -void -burstWct(Wct *pwct) -{ - while (pwct) { - burst1Wct(pwct); - pwct = pwct->next; - } -} - -void -burst1Wct(Wct *pwct) -{ - char *s, **wv; - int i, j, inword = 0; - - - for (s = pwct->fimage, i = 0; i < pwct->fsize; s++, i++) { - if (isspace(*s) || iscntrl(*s)) { - *s = 0; - inword = 0; - } - else if (!inword) { - inword = 1; - pwct->wordc++; - } - } - - if (pwct->wordv) - free(pwct->wordv); - pwct->wordv = (char **) calloc(pwct->wordc + 1, sizeof(char *)); - if (!pwct->wordv) - fatal("Could not make word list for %s.", pwct->fname); - - s = pwct->fimage; - i = 0; - for (wv = pwct->wordv, j = 0; j < pwct->wordc; wv++, j++) { - while (i < pwct->fsize && !s[i]) - i++; - *wv = s + i; - while (i < pwct->fsize && s[i]) - i++; - } - *wv = 0; -} - -Wct * -intern1Wct(char *fname) -{ - Wct *pwct; - - pwct = read1Wct(fname); - burst1Wct(pwct); - return pwct; -} - -void -reintern1Wct(Wct *pwct) -{ - reread1Wct(pwct); - burst1Wct(pwct); -} - -void -sfatal(char *s) -{ - fatal("%s", s); -} - -void -fatal(char *fmt,char * s) -{ - static char fbuf[256]; - - sprintf(fbuf, fmt, s); - - perror(fbuf); - exit(1); -} - - - -/* load up the wct database */ -void -load_wct_file(char *fname) -{ - pwct = nconcWct(intern1Wct(fname), pwct); -} - -void -skim_wct(void) -{ - skimWct(pwct); -} - -/* - * This routine is called when a tab is hit. It simply takes the current - * buffer and tries to find a completion of the last word on the line in the - * data base. - */ - - -void -rescan_wct(void) -{ - int b = curr_pntr - 1; - int old_len; - int new_len; - int diff; - int i; - int ncs = 0; - - /* - * first thing I should do is find my way back to the beginning of the - * word - */ - while (b && !Delimiter(buff[b])) - b--; - if (Delimiter(buff[b])) - b++; - - old_len = curr_pntr - b; - - pwix = rescanWct(); - - if (!pwix) { - putchar(_BELL); - fflush(stdout); - } - else { - Wct *pwct = pwix->pwct; /* start replacing it */ - - new_len = strlen(pwct->wordv[pwix->word]); - if (new_len > old_len) { - - /* - * I have to just slide the characters forward a bit, stuff in - * the new characters, and then adjust curr_pntr - */ - diff = new_len - old_len; - if (curr_pntr != buff_pntr) { - forwardcopy(&buff[curr_pntr + diff], - &buff[curr_pntr], - buff_pntr - curr_pntr); - forwardflag_cpy(&buff_flag[curr_pntr + diff], - &buff_flag[curr_pntr], - buff_pntr - curr_pntr); - } - buff_pntr += diff; - ncs = curr_pntr + diff; - - /* Now insert the new word */ - for (i = 0; i < new_len; i++) - buff[b + i] = (pwct->wordv[pwix->word])[i]; - - /* move cursor to the beginning of the word */ - for (; curr_pntr != b; curr_pntr--) - putchar(_BKSPC); - - /** now print the characters on the rest of the line **/ - printbuff(curr_pntr, buff_pntr - curr_pntr); - - /* now move bcak the number of characters I want to */ - for (i = buff_pntr; i != ncs; i--) - putchar(_BKSPC); - - fflush(stdout); - - curr_pntr = ncs; - } - else if (new_len < old_len) { - /* this time I simply copy backwards and do the substituting */ - diff = old_len - new_len; - strncpy(&buff[curr_pntr - diff], - &buff[curr_pntr], - buff_pntr - curr_pntr); - flagncpy(&buff_flag[curr_pntr - diff], - &buff_flag[curr_pntr], - buff_pntr - curr_pntr); - buff_pntr -= diff; - ncs = curr_pntr - diff; - - /* Now insert the new word */ - for (i = 0; i < new_len; i++) - buff[b + i] = (pwct->wordv[pwix->word])[i]; - - /* move cursor to the beginning of the word */ - for (; curr_pntr != b; curr_pntr--) - putchar(_BKSPC); - - /** now print the characters on the rest of the line **/ - printbuff(b, buff_pntr - b); - - /* now blank out the characters out on the end of this line */ - for (i = 0; i < diff; i++) - myputchar(' '); - - /* now move back the number of characters I want to */ - for (i = buff_pntr + diff; i != ncs; i--) - putchar(_BKSPC); - - fflush(stdout); - - curr_pntr = ncs; - } - else { - diff = 0; - ncs = curr_pntr; - /* Now insert the new word */ - for (i = 0; i < new_len; i++) - buff[b + i] = (pwct->wordv[pwix->word])[i]; - - /* move cursor to the beginning of the word */ - for (; curr_pntr != b; curr_pntr--) - putchar(_BKSPC); - - /** now print the characters on the rest of the line **/ - printbuff(curr_pntr, buff_pntr - curr_pntr); - - /* now move back the number of characters I want to */ - for (i = buff_pntr; i != ncs; i--) - putchar(_BKSPC); - - fflush(stdout); - - curr_pntr = ncs; - } - } -} - -void -find_wct(void) -{ - - char search_buff[100]; - char *filler = search_buff; - int b = curr_pntr - 1; - int e = curr_pntr; - int ne = 0; - int st; - Wix *pwix; - int curr_len; - int new_len; - int diff; - int i; - - /* - * First thing I do is try and construct the string to be searched for. - * Basically I just start from the curr_pntr and search backward until I - * find a blank. Once I find a blank I copy forward until I get back to - * curr_pntr; - */ - if (!curr_pntr) { - putchar(_BELL); - return; - } - /* then get back to the first blank or back to the beginning */ - while (b && !Delimiter(buff[b])) - b--; - if (Delimiter(buff[b])) - b++; - - /* At the same time, let me find the end of the word */ - while (e < buff_pntr && !Delimiter(buff[e])) { - e++; - ne++; - } - - st = b; - curr_len = e - b; - - /* now simply copy the text forward */ - while (b < curr_pntr) - *filler++ = buff[b++]; - - *filler = '\0'; - - pwix = scanWct(pwct, search_buff); - - /* - * else pwix = rescanWct(); - */ - - if (!pwix) { - putchar(_BELL); - fflush(stdout); - } - else { - Wct *pwct = pwix->pwct; - - /* - * printf("Found %s in file %s\n", pwct->wordv[pwix->word], - * pwct->fname); - */ - /* copy them buffer into where it should be */ - new_len = strlen(pwct->wordv[pwix->word]); - diff = new_len - curr_len; - if (curr_pntr != buff_pntr) { - forwardcopy(&buff[curr_pntr + diff], - &buff[curr_pntr], - buff_pntr - curr_pntr); - forwardflag_cpy(&buff_flag[curr_pntr + diff], - &buff_flag[curr_pntr], - buff_pntr - curr_pntr); - } - buff_pntr += diff; - - - /* Now insert the new characters */ - for (i = new_len - diff; i < new_len; i++) - buff[st + i] = (pwct->wordv[pwix->word])[i]; - - /* Now move the cursor forward to the end of the word */ - for (i = 0; i < diff; i++) - putchar(buff[curr_pntr++]); - - /** now print the characters on the rest of the line **/ - printbuff(curr_pntr, buff_pntr - curr_pntr); - - /* now move bcak the number of characters I want to */ - for (i = buff_pntr; i != e + diff; i--) - putchar(_BKSPC); - - fflush(stdout); - - curr_pntr = diff + e; - - } - - -} -@ -\section{License} -<>= -/* -Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - - Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - - Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in - the documentation and/or other materials provided with the - distribution. - - - Neither the name of The Numerical ALgorithms Group Ltd. nor the - names of its contributors may be used to endorse or promote products - derived from this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -@ -\newpage -\begin{thebibliography}{99} -\bibitem{1} nothing -\end{thebibliography} -\end{document} -- cgit v1.2.3