diff options
Diffstat (limited to 'shar/python-0.9.1-05-21.shar')
| -rw-r--r-- | shar/python-0.9.1-05-21.shar | 2528 |
1 files changed, 2528 insertions, 0 deletions
diff --git a/shar/python-0.9.1-05-21.shar b/shar/python-0.9.1-05-21.shar new file mode 100644 index 0000000..2d7f035 --- /dev/null +++ b/shar/python-0.9.1-05-21.shar @@ -0,0 +1,2528 @@ +: This is a shell archive. +: Extract with 'sh this_file'. +: +: Extract part 01 first since it makes all directories +echo 'Start of pack.out, part 05 out of 21:' +if test -s 'demo/sgi/audio_stdwin/README' +then echo '*** I will not over-write existing file demo/sgi/audio_stdwin/README' +else +echo 'x - demo/sgi/audio_stdwin/README' +sed 's/^X//' > 'demo/sgi/audio_stdwin/README' << 'EOF' +XThree programs that provide a user interface based upon STDWIN to the +Xaudio device of the SGI 4D/25. These scripts also demonstrate the power +Xof a set of window interface classes implemented in Python that simplify +Xthe construction of all sorts of buttons, etc. +X +Xjukebox Browses a directory full of sound samples and lets you +X play selected ones. (Probably not fully functional, it +X requires a conversion program.) +X +Xrec A tape recorder that lets you record a sound sample, +X play it back, and save it to a file. Various options to +X set sampling rate, volume etc. When idle it doubles +X as a VU meter. +X +Xvumeter A VU meter that displays a history of the volume of +X sound recently sampled from the microphone. +EOF +fi +if test -s 'src/panelmodule.c' +then echo '*** I will not over-write existing file src/panelmodule.c' +else +echo 'x - src/panelmodule.c' +sed 's/^X//' > 'src/panelmodule.c' << 'EOF' +X/*********************************************************** +XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The +XNetherlands. +X +X All Rights Reserved +X +XPermission to use, copy, modify, and distribute this software and its +Xdocumentation for any purpose and without fee is hereby granted, +Xprovided that the above copyright notice appear in all copies and that +Xboth that copyright notice and this permission notice appear in +Xsupporting documentation, and that the names of Stichting Mathematisch +XCentrum or CWI not be used in advertising or publicity pertaining to +Xdistribution of the software without specific, written prior permission. +X +XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +X +X******************************************************************/ +X +X/* Panel module. +X Interface to the NASA Ames "panel library" for the SGI Graphics Library +X by David Tristram. +X +X NOTE: the panel library dumps core if you don't create a window before +X calling pnl.mkpanel(). A call to gl.winopen() suffices. +X If you don't want a window to be created, call gl.noport() before +X gl.winopen(). +X*/ +X +X#include <gl.h> +X#include <device.h> +X#include <panel.h> +X +X#include "allobjects.h" +X#include "import.h" +X#include "modsupport.h" +X#include "cgensupport.h" +X +X +X/* The offsetof() macro calculates the offset of a structure member +X in its structure. Unfortunately this cannot be written down portably, +X hence it is standardized by ANSI C. For pre-ANSI C compilers, +X we give a version here that works usually (but watch out!): */ +X +X#ifndef offsetof +X#define offsetof(type, member) ( (int) & ((type*)0) -> member ) +X#endif +X +X +X/* Panel objects */ +X +Xtypedef struct { +X OB_HEAD +X Panel *ob_panel; +X object *ob_paneldict; +X} panelobject; +X +Xextern typeobject Paneltype; /* Really static, forward */ +X +X#define is_panelobject(v) ((v)->ob_type == &Paneltype) +X +X +X/* Actuator objects */ +X +Xtypedef struct { +X OB_HEAD +X Actuator *ob_actuator; +X} actuatorobject; +X +Xextern typeobject Actuatortype; /* Really static, forward */ +X +X#define is_actuatorobject(v) ((v)->ob_type == &Actuatortype) +X +Xstatic object *newactuatorobject(); /* Forward */ +X +X +X/* Since we allow different types of members than the functions from +X structmember.c, the memberlist stuff is replicated here. +X (Historically, it originated in this file and later became a generic +X feature.) */ +X +X/* An array of memberlist structures defines the name, type and offset +X of selected members of a C structure. These can be read by +X panel_getmember() and set by panel_setmember() (except if their +X READONLY flag is set). The array must be terminated with an entry +X whose name pointer is NULL. */ +X +Xstruct memberlist { +X char *name; +X int type; +X int offset; +X int readonly; +X}; +X +X/* Types */ +X#define T_SHORT 0 +X#define T_DEVICE T_SHORT +X#define T_LONG 1 +X#define T_INT T_LONG +X#define T_BOOL T_LONG +X#define T_FLOAT 2 +X#define T_COORD T_FLOAT +X#define T_STRING 3 +X#define T_FUNC 4 +X#define T_ACTUATOR 5 +X +X/* Readonly flag */ +X#define READONLY 1 +X#define RO READONLY /* Shorthand */ +X +Xstatic object * +Xpanel_getmember(addr, mlist, name) +X char *addr; +X struct memberlist *mlist; +X char *name; +X{ +X object *v; +X register struct memberlist *l; +X +X for (l = mlist; l->name != NULL; l++) { +X if (strcmp(l->name, name) == 0) { +X addr += l->offset; +X switch (l->type) { +X case T_SHORT: +X v = newintobject((long) *(short*)addr); +X break; +X case T_LONG: +X v = newintobject(*(long*)addr); +X break; +X case T_FLOAT: +X v = newfloatobject(*(float*)addr); +X break; +X case T_STRING: +X if (*(char**)addr == NULL) { +X INCREF(None); +X v = None; +X } +X else +X v = newstringobject(*(char**)addr); +X break; +X case T_ACTUATOR: +X v = newactuatorobject(*(Actuator**)addr); +X break; +X default: +X err_badarg(); +X v = NULL; +X } +X return v; +X } +X } +X err_setstr(NameError, name); +X return NULL; +X} +X +X/* Attempt to set a member. Return: 0 if OK; 1 if not found; -1 if error */ +X +Xstatic int +Xpanel_setmember(addr, mlist, name, v) +X char *addr; +X struct memberlist *mlist; +X char *name; +X object *v; +X{ +X register struct memberlist *l; +X +X for (l = mlist; l->name != NULL; l++) { +X if (strcmp(l->name, name) == 0) { +X if (l->readonly) { +X err_setstr(TypeError, "read-only member"); +X return -1; +X } +X addr += l->offset; +X switch (l->type) { +X case T_SHORT: +X if (!is_intobject(v)) { +X err_setstr(TypeError, "int expected"); +X return -1; +X } +X *(short*)addr = getintvalue(v); +X break; +X case T_LONG: +X if (!is_intobject(v)) { +X err_setstr(TypeError, "int expected"); +X return -1; +X } +X *(long*)addr = getintvalue(v); +X break; +X case T_FLOAT: +X if (is_intobject(v)) +X *(float*)addr = getintvalue(v); +X else if (is_floatobject(v)) +X *(float*)addr = getfloatvalue(v); +X else { +X err_setstr(TypeError,"float expected"); +X return -1; +X } +X break; +X case T_STRING: +X /* XXX Should free(*(char**)addr) here +X but it's dangerous since we don't know +X if we set the label ourselves */ +X if (v == None) +X *(char**)addr = NULL; +X else if (!is_stringobject(v)) { +X err_setstr(TypeError, +X "string expected"); +X return -1; +X } +X else +X *(char**)addr = +X strdup(getstringvalue(v)); +X break; +X case T_ACTUATOR: +X if (v == None) +X *(Actuator**)addr = NULL; +X else if (!is_actuatorobject(v)) { +X err_setstr(TypeError, +X "actuator expected"); +X return -1; +X } +X else +X *(Actuator**)addr = +X ((actuatorobject *)v)->ob_actuator; +X break; +X default: +X err_setstr(SystemError, "unknown member type"); +X return -1; +X } +X return 0; /* Found it */ +X } +X } +X +X return 1; /* Not found */ +X} +X +X +X/* Panel object methods */ +X +Xstatic object * +Xpanel_addpanel(self, args) +X panelobject *self; +X object *args; +X{ +X if (!getnoarg(args)) +X return NULL; +X pnl_addpanel(self->ob_panel); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xpanel_endgroup(self, args) +X panelobject *self; +X object *args; +X{ +X if (!getnoarg(args)) +X return NULL; +X pnl_endgroup(self->ob_panel); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xpanel_fixpanel(self, args) +X panelobject *self; +X object *args; +X{ +X if (!getnoarg(args)) +X return NULL; +X pnl_fixpanel(self->ob_panel); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xpanel_strwidth(self, args) +X panelobject *self; +X object *args; +X{ +X object *v; +X double width; +X if (!getstrarg(args, &v)) +X return NULL; +X width = pnl_strwidth(self->ob_panel, getstringvalue(v)); +X return newfloatobject(width); +X} +X +Xstatic struct methodlist panel_methods[] = { +X {"addpanel", panel_addpanel}, +X {"endgroup", panel_endgroup}, +X {"fixpanel", panel_fixpanel}, +X {"strwidth", panel_strwidth}, +X {NULL, NULL} /* sentinel */ +X}; +X +Xstatic object * +Xnewpanelobject() +X{ +X panelobject *p; +X p = NEWOBJ(panelobject, &Paneltype); +X if (p == NULL) +X return NULL; +X p->ob_panel = pnl_mkpanel(); +X if ((p->ob_paneldict = newdictobject()) == NULL) { +X DECREF(p); +X return NULL; +X } +X return (object *)p; +X} +X +Xstatic void +Xpanel_dealloc(p) +X panelobject *p; +X{ +X pnl_delpanel(p->ob_panel); +X if (p->ob_paneldict != NULL) +X DECREF(p->ob_paneldict); +X DEL(p); +X} +X +X +X/* Table of panel members */ +X +X#define PANOFF(member) offsetof(Panel, member) +X +Xstatic struct memberlist panel_memberlist[] = { +X {"id", T_SHORT, PANOFF(id), READONLY}, +X {"a", T_ACTUATOR, PANOFF(a), READONLY}, +X {"al", T_ACTUATOR, PANOFF(al), READONLY}, +X {"lastgroup", T_ACTUATOR, PANOFF(lastgroup), READONLY}, +X +X {"active", T_BOOL, PANOFF(active)}, +X {"selectable", T_BOOL, PANOFF(selectable)}, +X +X {"x", T_LONG, PANOFF(x)}, +X {"y", T_LONG, PANOFF(y)}, +X {"w", T_LONG, PANOFF(w)}, +X {"h", T_LONG, PANOFF(h)}, +X +X {"minx", T_COORD, PANOFF(minx)}, +X {"maxx", T_COORD, PANOFF(maxx)}, +X {"miny", T_COORD, PANOFF(miny)}, +X {"maxy", T_COORD, PANOFF(maxy)}, +X +X {"cw", T_COORD, PANOFF(cw)}, +X {"ch", T_COORD, PANOFF(ch)}, +X +X {"gid", T_LONG, PANOFF(gid), READONLY}, +X {"usergid", T_LONG, PANOFF(usergid), READONLY}, +X +X {"vobj", T_LONG, PANOFF(vobj), READONLY}, +X {"ppu", T_FLOAT, PANOFF(ppu)}, +X +X {"label", T_STRING, PANOFF(label)}, +X +X /* Panel callbacks are not supported */ +X +X {"visible", T_BOOL, PANOFF(visible)}, +X {"somedirty", T_INT, PANOFF(somedirty)}, +X {"dirtycnt", T_INT, PANOFF(dirtycnt)}, +X +X /* T_PANEL is not supported */ +X /* +X {"next", T_PANEL, PANOFF(next), READONLY}, +X */ +X +X {NULL, 0, 0} /* Sentinel */ +X}; +X +Xstatic object * +Xpanel_getattr(p, name) +X panelobject *p; +X char *name; +X{ +X object *v; +X +X v = dictlookup(p->ob_paneldict, name); +X if (v != NULL) { +X INCREF(v); +X return v; +X } +X +X v = findmethod(panel_methods, (object *)p, name); +X if (v != NULL) +X return v; +X err_clear(); +X return panel_getmember((char *)p->ob_panel, panel_memberlist, name); +X} +X +Xstatic int +Xpanel_setattr(p, name, v) +X panelobject *p; +X char *name; +X object *v; +X{ +X int err; +X +X /* We don't allow deletion of attributes */ +X if (v == NULL) { +X err_setstr(TypeError, "read-only panel attribute"); +X return -1; +X } +X err = panel_setmember((char *)p->ob_panel, panel_memberlist, name, v); +X if (err != 1) +X return err; +X return dictinsert(p->ob_paneldict, name, v); +X} +X +Xstatic typeobject Paneltype = { +X OB_HEAD_INIT(&Typetype) +X 0, /*ob_size*/ +X "panel", /*tp_name*/ +X sizeof(panelobject), /*tp_size*/ +X 0, /*tp_itemsize*/ +X /* methods */ +X panel_dealloc, /*tp_dealloc*/ +X 0, /*tp_print*/ +X panel_getattr, /*tp_getattr*/ +X panel_setattr, /*tp_setattr*/ +X 0, /*tp_compare*/ +X 0, /*tp_repr*/ +X}; +X +X +X/* Descriptions of actuator-specific data members */ +X +Xstruct memberlist slider_spec[] = { +X {"mode", T_INT, offsetof(Slider, mode)}, +X {"finefactor", T_FLOAT, offsetof(Slider, finefactor)}, +X {"differentialfactor", +X T_FLOAT, offsetof(Slider, differentialfactor)}, +X {"valsave", T_FLOAT, offsetof(Slider, valsave), RO}, +X {"wsave", T_COORD, offsetof(Slider, wsave)}, +X {"bh", T_COORD, offsetof(Slider, bh)}, +X {NULL} +X}; +X +X#define palette_spec slider_spec +X +Xstruct memberlist puck_spec[] = { +X /* Actuators already have members x and y, so the Puck's x and y +X have different names */ +X {"puck_x", T_FLOAT, offsetof(Puck, x)}, +X {"puck_y", T_FLOAT, offsetof(Puck, y)}, +X {NULL} +X}; +X +Xstruct memberlist dial_spec[] = { +X {"mode", T_INT, offsetof(Dial, mode)}, +X {"finefactor", T_FLOAT, offsetof(Dial, finefactor)}, +X {"valsave", T_FLOAT, offsetof(Dial, valsave), RO}, +X {"wsave", T_COORD, offsetof(Dial, wsave)}, +X {"winds", T_FLOAT, offsetof(Dial, winds)}, +X {NULL} +X}; +X +Xstruct memberlist slideroid_spec[] = { +X {"mode", T_INT, offsetof(Slideroid, mode)}, +X {"finemode", T_BOOL, offsetof(Slideroid, finemode)}, +X {"resetmode", T_BOOL, offsetof(Slideroid, resetmode)}, +X /* XXX Can't do resettarget (pointer to float) */ +X /* XXX This makes resetval pretty useless... */ +X /* +X {"resetval", T_FLOAT, offsetof(Slideroid, resetval)}, +X */ +X {"valsave", T_FLOAT, offsetof(Slideroid, valsave), RO}, +X {"wsave", T_COORD, offsetof(Slideroid, wsave)}, +X {NULL} +X}; +X +Xstruct memberlist stripchart_spec[] = { +X {"firstpt", T_INT, offsetof(Stripchart, firstpt), RO}, +X {"lastpt", T_INT, offsetof(Stripchart, lastpt), RO}, +X {"Bind_Low", T_BOOL, offsetof(Stripchart, Bind_Low)}, +X {"Bind_High", T_BOOL, offsetof(Stripchart, Bind_High)}, +X /* XXX Can't do y (array of floats) */ +X {"lowlabel", T_ACTUATOR, offsetof(Stripchart, lowlabel), RO}, +X {"highlabel", T_ACTUATOR, offsetof(Stripchart, highlabel), RO}, +X {NULL} +X}; +X +Xstruct memberlist typein_spec[] = { +X /* Note: these should be readonly after the actuator is added +X to a panel */ +X {"str", T_STRING, offsetof(Typein, str)}, +X {"len", T_INT, offsetof(Typein, len)}, +X {NULL} +X}; +X +Xstruct memberlist typeout_spec[] = { +X {"mode", T_INT, offsetof(Typeout, mode)}, +X /* XXX The buffer is managed by the actuator; but how do we +X add text? */ +X {"buf", T_STRING, offsetof(Typeout, buf), READONLY}, +X {"delimstr", T_STRING, offsetof(Typeout, delimstr)}, +X {"start", T_INT, offsetof(Typeout, start)}, +X {"dot", T_INT, offsetof(Typeout, dot)}, +X {"mark", T_INT, offsetof(Typeout, mark)}, +X {"col", T_INT, offsetof(Typeout, col)}, +X {"lin", T_INT, offsetof(Typeout, lin)}, +X {"len", T_INT, offsetof(Typeout, len)}, +X {"size", T_INT, offsetof(Typeout, size)}, +X {NULL} +X}; +X +Xstruct memberlist mouse_spec[] = { +X /* Actuators already have members x and y, so the Mouse's x and y +X have different names */ +X {"mouse_x", T_FLOAT, offsetof(Mouse, x)}, +X {"mouse_y", T_FLOAT, offsetof(Mouse, y)}, +X {NULL} +X}; +X +X#define MULOFF(member) offsetof(Multislider, member) +X +Xstruct memberlist multislider_spec[] = { +X {"mode", T_INT, MULOFF(mode)}, +X {"n", T_INT, MULOFF(n)}, +X {"finefactor", T_FLOAT, MULOFF(finefactor)}, +X {"wsave", T_COORD, MULOFF(wsave)}, +X {"sa", T_ACTUATOR, MULOFF(sa)}, +X {"bh", T_COORD, MULOFF(bh)}, +X {"clrx", T_COORD, MULOFF(clrx)}, +X {"clry", T_COORD, MULOFF(clry)}, +X {"clrw", T_COORD, MULOFF(clrw)}, +X {"clrh", T_COORD, MULOFF(clrh)}, +X /* XXX acttype? */ +X {NULL} +X}; +X +X/* XXX Still to do: +X Frame +X Icon +X Cycle +X Scroll +X Menu +X*/ +X +X/* List of known actuator initializer functions */ +X +Xstruct { +X char *name; +X void (*func)(); +X struct memberlist *spec; +X} initializerlist[] = { +X {"analog_bar", pnl_analog_bar}, +X {"analog_meter", pnl_analog_meter}, +X {"button", pnl_button}, +X {"cycle", pnl_cycle}, +X /* Doesn't exist: */ +X/* {"dhslider", pnl_dhslider, slider_spec}, */ +X {"dial", pnl_dial, dial_spec}, +X {"down_arrow_button", pnl_down_arrow_button}, +X {"down_double_arrow_button", pnl_down_double_arrow_button}, +X {"dvslider", pnl_dvslider, slider_spec}, +X {"filled_hslider", pnl_filled_hslider, slider_spec}, +X {"filled_slider", pnl_filled_slider, slider_spec}, +X {"filled_vslider", pnl_filled_vslider, slider_spec}, +X {"floating_puck", pnl_floating_puck, puck_spec}, +X {"frame", pnl_frame}, +X {"graphframe", pnl_graphframe}, +X {"hmultislider", pnl_hmultislider, multislider_spec}, +X {"hmultislider_bar", pnl_hmultislider_bar}, +X {"hmultislider_open_bar", pnl_hmultislider_open_bar}, +X {"hpalette", pnl_hpalette, palette_spec}, +X {"hslider", pnl_hslider, slider_spec}, +X {"icon", pnl_icon}, +X {"icon_menu", pnl_icon_menu}, +X {"label", pnl_label}, +X {"left_arrow_button", pnl_left_arrow_button}, +X {"left_double_arrow_button", pnl_left_double_arrow_button}, +X {"menu", pnl_menu}, +X {"menu_item", pnl_menu_item}, +X {"meter", pnl_meter}, +X {"mouse", pnl_mouse, mouse_spec}, +X {"multislider", pnl_multislider, multislider_spec}, +X {"multislider_bar", pnl_multislider_bar}, +X {"multislider_open_bar", pnl_multislider_open_bar}, +X {"palette", pnl_palette, palette_spec}, +X {"puck", pnl_puck, puck_spec}, +X {"radio_button", pnl_radio_button}, +X {"radio_check_button", pnl_radio_check_button}, +X {"right_arrow_button", pnl_right_arrow_button}, +X {"right_double_arrow_button", pnl_right_double_arrow_button}, +X {"rubber_puck", pnl_rubber_puck, puck_spec}, +X {"scale_chart", pnl_scale_chart, stripchart_spec}, +X {"scroll", pnl_scroll}, +X {"signal", pnl_signal}, +X {"slider", pnl_slider, slider_spec}, +X {"slideroid", pnl_slideroid, slideroid_spec}, +X {"strip_chart", pnl_strip_chart, stripchart_spec}, +X {"sub_menu", pnl_sub_menu}, +X {"toggle_button", pnl_toggle_button}, +X {"typein", pnl_typein, typein_spec}, +X {"typeout", pnl_typeout, typeout_spec}, +X {"up_arrow_button", pnl_up_arrow_button}, +X {"up_double_arrow_button", pnl_up_double_arrow_button}, +X {"viewframe", pnl_viewframe}, +X {"vmultislider", pnl_vmultislider, multislider_spec}, +X {"vmultislider_bar", pnl_vmultislider_bar}, +X {"vmultislider_open_bar", pnl_vmultislider_open_bar}, +X {"vpalette", pnl_vpalette, palette_spec}, +X {"vslider", pnl_vslider, slider_spec}, +X {"wide_button", pnl_wide_button}, +X {NULL, NULL} /* Sentinel */ +X}; +X +X +X/* Pseudo downfunc etc. */ +X +Xstatic Actuator *down_pend, *active_pend, *up_pend; +X +Xstatic void +Xdownfunc(a) +X Actuator *a; +X{ +X if (down_pend == NULL) +X down_pend = a; +X} +X +Xstatic void +Xactivefunc(a) +X Actuator *a; +X{ +X if (active_pend == NULL) +X active_pend = a; +X} +X +Xstatic void +Xupfunc(a) +X Actuator *a; +X{ +X if (up_pend == NULL) +X up_pend = a; +X} +X +X +X/* Lay-out for the user data */ +X +Xstruct userdata { +X object *dict; /* Dictionary object for additional attributes */ +X struct memberlist *spec; /* Actuator-specific members */ +X}; +X +X +X/* Create a new actuator; the actuator type is given as a string */ +X +Xstatic Actuator * +Xmakeactuator(name) +X char *name; +X{ +X Actuator *act; +X void (*initializer)() = NULL; +X int i; +X struct userdata *u; +X for (i = 0; initializerlist[i].name != NULL; i++) { +X if (strcmp(initializerlist[i].name, name) == 0) { +X initializer = initializerlist[i].func; +X break; +X } +X } +X if (initializerlist[i].name == NULL) { +X err_badarg(); +X return NULL; +X } +X u = NEW(struct userdata, 1); +X if (u == NULL) { +X err_nomem(); +X return NULL; +X } +X u->dict = NULL; +X u->spec = initializerlist[i].spec; +X act = pnl_mkact(initializer); +X act->u = (char *)u; +X act->downfunc = downfunc; +X act->activefunc = activefunc; +X act->upfunc = upfunc; +X return act; +X} +X +X +X/* Actuator objects methods */ +X +Xstatic object * +Xactuator_addact(self, args) +X actuatorobject *self; +X object *args; +X{ +X Panel *p; +X if (!is_panelobject(args)) { +X err_badarg(); +X return NULL; +X } +X p = ((panelobject *)args) -> ob_panel; +X pnl_addact(self->ob_actuator, p); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xactuator_addsubact(self, args) +X actuatorobject *self; +X object *args; +X{ +X Actuator *a; +X if (!is_actuatorobject(args)) { +X err_badarg(); +X return NULL; +X } +X a = ((actuatorobject *)args) -> ob_actuator; +X pnl_addsubact(self->ob_actuator, a); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xactuator_delact(self, args) +X actuatorobject *self; +X object *args; +X{ +X Panel *p; +X if (!getnoarg(args)) +X return NULL; +X pnl_delact(self->ob_actuator); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xactuator_fixact(self, args) +X actuatorobject *self; +X object *args; +X{ +X Panel *p; +X if (!getnoarg(args)) +X return NULL; +X pnl_fixact(self->ob_actuator); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xactuator_tprint(self, args) +X actuatorobject *self; +X object *args; +X{ +X object *str; +X if (self->ob_actuator->type != PNL_TYPEOUT) { +X err_setstr(TypeError, "tprint for non-typeout panel"); +X return NULL; +X } +X if (!getstrarg(args, &str)) +X return NULL; +X tprint(self->ob_actuator, getstringvalue(str)); +X /* XXX Can't turn tprint's errors into exceptions, sorry */ +X INCREF(None); +X return None; +X} +X +Xstatic struct methodlist actuator_methods[] = { +X {"addact", actuator_addact}, +X {"addsubact", actuator_addsubact}, +X {"delact", actuator_delact}, +X {"fixact", actuator_fixact}, +X {"tprint", actuator_tprint}, +X {NULL, NULL} /* sentinel */ +X}; +X +Xstatic object * +Xnewactuatorobject(act) +X Actuator *act; +X{ +X actuatorobject *a; +X if (act == NULL) { +X INCREF(None); +X return None; +X } +X a = NEWOBJ(actuatorobject, &Actuatortype); +X if (a == NULL) +X return NULL; +X a->ob_actuator = act; +X return (object *)a; +X} +X +Xstatic void +Xactuator_dealloc(a) +X actuatorobject *a; +X{ +X /* Do NOT delete the actuator; most actuator objects are created +X to hold a temporary reference to an actuator, like one gotten +X from pnl_dopanel(). */ +X +X DEL(a); +X} +X +X +X/* Table of actuator members */ +X +X#define ACTOFF(member) offsetof(Actuator, member) +X +Xstruct memberlist act_memberlist[] = { +X {"id", T_SHORT, ACTOFF(id), READONLY}, +X +X /* T_PANEL is not defined */ +X /* +X {"p", T_PANEL, ACTOFF(p), READONLY}, +X */ +X +X {"pa", T_ACTUATOR, ACTOFF(pa), READONLY}, +X {"ca", T_ACTUATOR, ACTOFF(ca), READONLY}, +X {"al", T_ACTUATOR, ACTOFF(al), READONLY}, +X {"na", T_INT, ACTOFF(na), READONLY}, +X {"type", T_INT, ACTOFF(type), READONLY}, +X {"active", T_BOOL, ACTOFF(active)}, +X +X {"x", T_COORD, ACTOFF(x)}, +X {"y", T_COORD, ACTOFF(y)}, +X {"w", T_COORD, ACTOFF(w)}, +X {"h", T_COORD, ACTOFF(h)}, +X +X {"lx", T_COORD, ACTOFF(lx)}, +X {"ly", T_COORD, ACTOFF(ly)}, +X {"lw", T_COORD, ACTOFF(lw)}, +X {"lh", T_COORD, ACTOFF(lh)}, +X {"ld", T_COORD, ACTOFF(ld)}, +X +X {"val", T_FLOAT, ACTOFF(val)}, +X {"extval", T_FLOAT, ACTOFF(extval)}, +X {"initval", T_FLOAT, ACTOFF(initval)}, +X {"maxval", T_FLOAT, ACTOFF(maxval)}, +X {"minval", T_FLOAT, ACTOFF(minval)}, +X {"scalefactor", T_FLOAT, ACTOFF(scalefactor)}, +X +X {"label", T_STRING, ACTOFF(label)}, +X {"key", T_DEVICE, ACTOFF(key)}, +X {"labeltype", T_INT, ACTOFF(labeltype)}, +X +X /* Internal callbacks are not supported; +X user callbacks are treated special! */ +X +X {"dirtycnt", T_INT, ACTOFF(dirtycnt)}, +X +X /* members u and data are accessed differently */ +X +X {"automatic", T_BOOL, ACTOFF(automatic)}, +X {"selectable", T_BOOL, ACTOFF(selectable)}, +X {"visible", T_BOOL, ACTOFF(visible)}, +X {"beveled", T_BOOL, ACTOFF(beveled)}, +X +X {"group", T_ACTUATOR, ACTOFF(group), READONLY}, +X {"next", T_ACTUATOR, ACTOFF(next), READONLY}, +X +X {NULL, 0, 0} /* Sentinel */ +X}; +X +X +X/* Potential name conflicts between attributes are solved as follows. +X - Actuator-specific attributes always override generic attributes. +X - When reading, the dictionary has overrides everything else; +X when writing, everything else overrides the dictionary. +X - When reading, methods are tried last. +X*/ +X +Xstatic object * +Xactuator_getattr(a, name) +X actuatorobject *a; +X char *name; +X{ +X Actuator *act = a->ob_actuator; +X struct userdata *u = (struct userdata *) act->u; +X object *v; +X +X if (u != NULL) { +X /* 1. Try the dictionary */ +X if (u->dict != NULL) { +X v = dictlookup(u->dict, name); +X if (v != NULL) { +X INCREF(v); +X return v; +X } +X } +X +X /* 2. Try actuator-specific attributes */ +X if (u->spec != NULL) { +X v = panel_getmember(act->data, u->spec, name); +X if (v != NULL) +X return v; +X err_clear(); +X } +X } +X +X /* 3. Try generic actuator attributes */ +X v = panel_getmember((char *)act, act_memberlist, name); +X if (v != NULL) +X return v; +X +X /* 4. Try methods */ +X err_clear(); +X return findmethod(actuator_methods, (object *)a, name); +X} +X +Xstatic int +Xactuator_setattr(a, name, v) +X actuatorobject *a; +X char *name; +X object *v; +X{ +X Actuator *act = a->ob_actuator; +X struct userdata *u = (struct userdata *) act->u; +X int err; +X +X /* 0. We don't allow deletion of attributes */ +X if (v == NULL) { +X err_setstr(TypeError, "read-only actuator attribute"); +X return -1; +X } +X +X /* 1. Try actuator-specific attributes */ +X if (u != NULL && u->spec != NULL) { +X err = panel_setmember(act->data, u->spec, name, v); +X if (err != 1) +X return err; +X } +X +X /* 2. Try generic actuator attributes */ +X err = panel_setmember((char *)act, act_memberlist, name, v); +X if (err != 1) +X return err; +X +X /* 3. Try the dictionary */ +X if (u != NULL) { +X if (u->dict == NULL && (u->dict = newdictobject()) == NULL) +X return NULL; +X return dictinsert(u->dict, name, v); +X } +X +X err_setstr(NameError, name); +X return -1; +X} +X +Xstatic int +Xactuator_compare(v, w) +X actuatorobject *v, *w; +X{ +X long i = (long)v->ob_actuator; +X long j = (long)w->ob_actuator; +X return (i < j) ? -1 : (i > j) ? 1 : 0; +X} +X +Xstatic typeobject Actuatortype = { +X OB_HEAD_INIT(&Typetype) +X 0, /*ob_size*/ +X "actuator", /*tp_name*/ +X sizeof(actuatorobject), /*tp_size*/ +X 0, /*tp_itemsize*/ +X /* methods */ +X actuator_dealloc, /*tp_dealloc*/ +X 0, /*tp_print*/ +X actuator_getattr, /*tp_getattr*/ +X actuator_setattr, /*tp_setattr*/ +X actuator_compare, /*tp_compare*/ +X 0, /*tp_repr*/ +X}; +X +X +X/* The panel module itself */ +X +Xstatic object * +Xmodule_mkpanel(self, args) +X object *self; +X object *args; +X{ +X if (!getnoarg(args)) +X return NULL; +X return newpanelobject(); +X} +X +Xstatic object * +Xmodule_mkact(self, args) +X object *self; +X object *args; +X{ +X object *v; +X Actuator *a; +X if (!getstrarg(args, &v)) +X return NULL; +X a = makeactuator(getstringvalue(v)); +X if (a == NULL) +X return NULL; +X return newactuatorobject(a); +X} +X +Xstatic object * +Xmodule_dopanel(self, args) +X object *self; +X object *args; +X{ +X Actuator *a; +X object *v, *w; +X if (!getnoarg(args)) +X return NULL; +X a = pnl_dopanel(); +X v = newtupleobject(4); +X if (v == NULL) +X return NULL; +X settupleitem(v, 0, newactuatorobject(a)); +X settupleitem(v, 1, newactuatorobject(down_pend)); +X settupleitem(v, 2, newactuatorobject(active_pend)); +X settupleitem(v, 3, newactuatorobject(up_pend)); +X down_pend = active_pend = up_pend = NULL; +X return v; +X} +X +Xstatic object * +Xmodule_drawpanel(self, args) +X object *self; +X object *args; +X{ +X if (!getnoarg(args)) +X return NULL; +X pnl_drawpanel(); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xmodule_needredraw(self, args) +X object *self; +X object *args; +X{ +X if (!getnoarg(args)) +X return NULL; +X pnl_needredraw(); +X INCREF(None); +X return None; +X} +X +Xstatic object * +Xmodule_userredraw(self, args) +X object *self; +X object *args; +X{ +X short wid; +X if (!getnoarg(args)) +X return NULL; +X wid = pnl_userredraw(); +X return newintobject((long)wid); +X} +X +Xstatic object * +Xmodule_block(self, args) +X object *self; +X object *args; +X{ +X int flag; +X if (!getintarg(args, &flag)) +X return NULL; +X pnl_block = flag; +X INCREF(None); +X return None; +X} +X +Xstatic struct methodlist module_methods[] = { +X {"block", module_block}, +X {"dopanel", module_dopanel}, +X {"drawpanel", module_drawpanel}, +X {"mkpanel", module_mkpanel}, +X {"mkact", module_mkact}, +X {"needredraw", module_needredraw}, +X {"userredraw", module_userredraw}, +X {NULL, NULL} /* sentinel */ +X}; +X +Xvoid +Xinitpanel() +X{ +X /* Setting pnl_block to 1 would greatly reduce the CPU usage +X of an idle application. Unfortunately it also breaks our +X little hacks to get callback functions in Python called. +X So we clear pnl_block here. You can set/clear pnl_block +X from Python using pnl.block(flag). It works if you have +X no upfuncs. */ +X pnl_block = 0; +X initmodule("pnl", module_methods); +X} +EOF +fi +if test -s 'src/regexp.c' +then echo '*** I will not over-write existing file src/regexp.c' +else +echo 'x - src/regexp.c' +sed 's/^X//' > 'src/regexp.c' << 'EOF' +X/*********************************************************** +XCopyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The +XNetherlands. +X +X All Rights Reserved +X +XPermission to use, copy, modify, and distribute this software and its +Xdocumentation for any purpose and without fee is hereby granted, +Xprovided that the above copyright notice appear in all copies and that +Xboth that copyright notice and this permission notice appear in +Xsupporting documentation, and that the names of Stichting Mathematisch +XCentrum or CWI not be used in advertising or publicity pertaining to +Xdistribution of the software without specific, written prior permission. +X +XSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +XTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +XFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +XFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +XWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +XACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +XOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +X +X******************************************************************/ +X +X/* +X * regcomp and regexec -- regsub and regerror are elsewhere +X * +X * Copyright (c) 1986 by University of Toronto. +X * Written by Henry Spencer. Not derived from licensed software. +X#ifdef MULTILINE +X * Changed by Guido van Rossum, CWI, Amsterdam +X * for multi-line support. +X#endif +X * +X * Permission is granted to anyone to use this software for any +X * purpose on any computer system, and to redistribute it freely, +X * subject to the following restrictions: +X * +X * 1. The author is not responsible for the consequences of use of +X * this software, no matter how awful, even if they arise +X * from defects in it. +X * +X * 2. The origin of this software must not be misrepresented, either +X * by explicit claim or by omission. +X * +X * 3. Altered versions must be plainly marked as such, and must not +X * be misrepresented as being the original software. +X * +X * Beware that some of this code is subtly aware of the way operator +X * precedence is structured in regular expressions. Serious changes in +X * regular-expression syntax might require a total rethink. +X */ +X#include <stdio.h> +X#include "PROTO.h" +X#include "malloc.h" +X#undef ANY /* Conflicting identifier defined in malloc.h */ +X#include <string.h> /* XXX Remove if not found */ +X#include "regexp.h" +X#include "regmagic.h" +X +X#ifdef MULTILINE +X/* +X * Defining MULTILINE turns on the following changes in the semantics: +X * 1. The '.' operator matches all characters except a newline. +X * 2. The '^' operator matches at the beginning of the string or after +X * a newline. (Anchored matches are retried after each newline.) +X * 3. The '$' operator matches at the end of the string or before +X * a newline. +X * 4. A '\' followed by an 'n' matches a newline. (This is an +X * unfortunate exception to the rule that '\' followed by a +X * character matches that character...) +X * +X * Also, there is a new function reglexec(prog, string, offset) +X * which searches for a match starting at 'string+offset'; +X * it differs from regexec(prog, string+offset) in assuming +X * that the line begins at 'string'. +X */ +X#endif +X +X/* +X * The "internal use only" fields in regexp.h are present to pass info from +X * compile to execute that permits the execute phase to run lots faster on +X * simple cases. They are: +X * +X * regstart char that must begin a match; '\0' if none obvious +X * reganch is the match anchored (at beginning-of-line only)? +X * regmust string (pointer into program) that match must include, or NULL +X * regmlen length of regmust string +X * +X * Regstart and reganch permit very fast decisions on suitable starting points +X * for a match, cutting down the work a lot. Regmust permits fast rejection +X * of lines that cannot possibly match. The regmust tests are costly enough +X * that regcomp() supplies a regmust only if the r.e. contains something +X * potentially expensive (at present, the only such thing detected is * or + +X * at the start of the r.e., which can involve a lot of backup). Regmlen is +X * supplied because the test in regexec() needs it and regcomp() is computing +X * it anyway. +X */ +X +X/* +X * Structure for regexp "program". This is essentially a linear encoding +X * of a nondeterministic finite-state machine (aka syntax charts or +X * "railroad normal form" in parsing technology). Each node is an opcode +X * plus a "next" pointer, possibly plus an operand. "Next" pointers of +X * all nodes except BRANCH implement concatenation; a "next" pointer with +X * a BRANCH on both ends of it is connecting two alternatives. (Here we +X * have one of the subtle syntax dependencies: an individual BRANCH (as +X * opposed to a collection of them) is never concatenated with anything +X * because of operator precedence.) The operand of some types of node is +X * a literal string; for others, it is a node leading into a sub-FSM. In +X * particular, the operand of a BRANCH node is the first node of the branch. +X * (NB this is *not* a tree structure: the tail of the branch connects +X * to the thing following the set of BRANCHes.) The opcodes are: +X */ +X +X/* definition number opnd? meaning */ +X#define END 0 /* no End of program. */ +X#define BOL 1 /* no Match "" at beginning of line. */ +X#define EOL 2 /* no Match "" at end of line. */ +X#define ANY 3 /* no Match any one character. */ +X#define ANYOF 4 /* str Match any character in this string. */ +X#define ANYBUT 5 /* str Match any character not in this string. */ +X#define BRANCH 6 /* node Match this alternative, or the next... */ +X#define BACK 7 /* no Match "", "next" ptr points backward. */ +X#define EXACTLY 8 /* str Match this string. */ +X#define NOTHING 9 /* no Match empty string. */ +X#define STAR 10 /* node Match this (simple) thing 0 or more times. */ +X#define PLUS 11 /* node Match this (simple) thing 1 or more times. */ +X#define OPEN 20 /* no Mark this point in input as start of #n. */ +X /* OPEN+1 is number 1, etc. */ +X#define CLOSE 30 /* no Analogous to OPEN. */ +X +X/* +X * Opcode notes: +X * +X * BRANCH The set of branches constituting a single choice are hooked +X * together with their "next" pointers, since precedence prevents +X * anything being concatenated to any individual branch. The +X * "next" pointer of the last BRANCH in a choice points to the +X * thing following the whole choice. This is also where the +X * final "next" pointer of each individual branch points; each +X * branch starts with the operand node of a BRANCH node. +X * +X * BACK Normal "next" pointers all implicitly point forward; BACK +X * exists to make loop structures possible. +X * +X * STAR,PLUS '?', and complex '*' and '+', are implemented as circular +X * BRANCH structures using BACK. Simple cases (one character +X * per match) are implemented with STAR and PLUS for speed +X * and to minimize recursive plunges. +X * +X * OPEN,CLOSE ...are numbered at compile time. +X */ +X +X/* +X * A node is one char of opcode followed by two chars of "next" pointer. +X * "Next" pointers are stored as two 8-bit pieces, high order first. The +X * value is a positive offset from the opcode of the node containing it. +X * An operand, if any, simply follows the node. (Note that much of the +X * code generation knows about this implicit relationship.) +X * +X * Using two bytes for the "next" pointer is vast overkill for most things, +X * but allows patterns to get big without disasters. +X */ +X#define OP(p) (*(p)) +X#define NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377)) +X#define OPERAND(p) ((p) + 3) +X +X/* +X * See regmagic.h for one further detail of program structure. +X */ +X +X +X/* +X * Utility definitions. +X */ +X#ifndef CHARBITS +X#define UCHARAT(p) ((int)*(unsigned char *)(p)) +X#else +X#define UCHARAT(p) ((int)*(p)&CHARBITS) +X#endif +X +X#define FAIL(m) { regerror(m); return(NULL); } +X#define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?') +X#define META "^$.[()|?+*\\" +X +X/* +X * Flags to be passed up and down. +X */ +X#define HASWIDTH 01 /* Known never to match null string. */ +X#define SIMPLE 02 /* Simple enough to be STAR/PLUS operand. */ +X#define SPSTART 04 /* Starts with * or +. */ +X#define WORST 0 /* Worst case. */ +X +X/* +X * Global work variables for regcomp(). +X */ +Xstatic char *regparse; /* Input-scan pointer. */ +Xstatic int regnpar; /* () count. */ +Xstatic char regdummy; +Xstatic char *regcode; /* Code-emit pointer; ®dummy = don't. */ +Xstatic long regsize; /* Code size. */ +X#ifdef MULTILINE +Xstatic int regnl; /* '\n' detected. */ +X#endif +X +X/* +X * Forward declarations for regcomp()'s friends. +X */ +X#ifndef STATIC +X#define STATIC static +X#endif +XSTATIC char *reg(); +XSTATIC char *regbranch(); +XSTATIC char *regpiece(); +XSTATIC char *regatom(); +XSTATIC char *regnode(); +XSTATIC char *regnext(); +XSTATIC void regc(); +XSTATIC void reginsert(); +XSTATIC void regtail(); +XSTATIC void regoptail(); +X#ifdef STRCSPN +XSTATIC int strcspn(); +X#endif +X +X/* +X - regcomp - compile a regular expression into internal code +X * +X * We can't allocate space until we know how big the compiled form will be, +X * but we can't compile it (and thus know how big it is) until we've got a +X * place to put the code. So we cheat: we compile it twice, once with code +X * generation turned off and size counting turned on, and once "for real". +X * This also means that we don't allocate space until we are sure that the +X * thing really will compile successfully, and we never have to move the +X * code and thus invalidate pointers into it. (Note that it has to be in +X * one piece because free() must be able to free it all.) +X * +X * Beware that the optimization-preparation code in here knows about some +X * of the structure of the compiled regexp. +X */ +Xregexp * +Xregcomp(exp) +Xchar *exp; +X{ +X register regexp *r; +X register char *scan; +X register char *longest; +X register int len; +X int flags; +X +X if (exp == NULL) +X FAIL("NULL argument"); +X +X /* First pass: determine size, legality. */ +X regparse = exp; +X regnpar = 1; +X regsize = 0L; +X regcode = ®dummy; +X#ifdef MULTILINE +X regnl = 0; +X#endif +X regc(MAGIC); +X if (reg(0, &flags) == NULL) +X return(NULL); +X +X /* Small enough for pointer-storage convention? */ +X if (regsize >= 32767L) /* Probably could be 65535L. */ +X FAIL("regexp too big"); +X +X /* Allocate space. */ +X r = (regexp *)malloc(sizeof(regexp) + (unsigned)regsize); +X if (r == NULL) +X FAIL("out of space"); +X +X /* Second pass: emit code. */ +X regparse = exp; +X regnpar = 1; +X regcode = r->program; +X regc(MAGIC); +X if (reg(0, &flags) == NULL) +X return(NULL); +X +X /* Dig out information for optimizations. */ +X r->regstart = '\0'; /* Worst-case defaults. */ +X r->reganch = 0; +X r->regmust = NULL; +X r->regmlen = 0; +X scan = r->program+1; /* First BRANCH. */ +X if (OP(regnext(scan)) == END) { /* Only one top-level choice. */ +X scan = OPERAND(scan); +X +X /* Starting-point info. */ +X if (OP(scan) == EXACTLY) +X r->regstart = *OPERAND(scan); +X else if (OP(scan) == BOL) +X r->reganch++; +X +X /* +X * If there's something expensive in the r.e., find the +X * longest literal string that must appear and make it the +X * regmust. Resolve ties in favor of later strings, since +X * the regstart check works with the beginning of the r.e. +X * and avoiding duplication strengthens checking. Not a +X * strong reason, but sufficient in the absence of others. +X */ +X#ifdef MULTILINE +X if ((flags&SPSTART) && !regnl) { +X#else +X if (flags&SPSTART) { +X#endif +X longest = NULL; +X len = 0; +X for (; scan != NULL; scan = regnext(scan)) +X if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) { +X longest = OPERAND(scan); +X len = strlen(OPERAND(scan)); +X } +X r->regmust = longest; +X r->regmlen = len; +X } +X } +X +X return(r); +X} +X +X/* +X - reg - regular expression, i.e. main body or parenthesized thing +X * +X * Caller must absorb opening parenthesis. +X * +X * Combining parenthesis handling with the base level of regular expression +X * is a trifle forced, but the need to tie the tails of the branches to what +X * follows makes it hard to avoid. +X */ +Xstatic char * +Xreg(paren, flagp) +Xint paren; /* Parenthesized? */ +Xint *flagp; +X{ +X register char *ret; +X register char *br; +X register char *ender; +X register int parno; +X int flags; +X +X *flagp = HASWIDTH; /* Tentatively. */ +X +X /* Make an OPEN node, if parenthesized. */ +X if (paren) { +X if (regnpar >= NSUBEXP) +X FAIL("too many ()"); +X parno = regnpar; +X regnpar++; +X ret = regnode(OPEN+parno); +X } else +X ret = NULL; +X +X /* Pick up the branches, linking them together. */ +X br = regbranch(&flags); +X if (br == NULL) +X return(NULL); +X if (ret != NULL) +X regtail(ret, br); /* OPEN -> first. */ +X else +X ret = br; +X if (!(flags&HASWIDTH)) +X *flagp &= ~HASWIDTH; +X *flagp |= flags&SPSTART; +X while (*regparse == '|') { +X regparse++; +X br = regbranch(&flags); +X if (br == NULL) +X return(NULL); +X regtail(ret, br); /* BRANCH -> BRANCH. */ +X if (!(flags&HASWIDTH)) +X *flagp &= ~HASWIDTH; +X *flagp |= flags&SPSTART; +X } +X +X /* Make a closing node, and hook it on the end. */ +X ender = regnode((paren) ? CLOSE+parno : END); +X regtail(ret, ender); +X +X /* Hook the tails of the branches to the closing node. */ +X for (br = ret; br != NULL; br = regnext(br)) +X regoptail(br, ender); +X +X /* Check for proper termination. */ +X if (paren && *regparse++ != ')') { +X FAIL("unmatched ()"); +X } else if (!paren && *regparse != '\0') { +X if (*regparse == ')') { +X FAIL("unmatched ()"); +X } else +X FAIL("junk on end"); /* "Can't happen". */ +X /* NOTREACHED */ +X } +X +X return(ret); +X} +X +X/* +X - regbranch - one alternative of an | operator +X * +X * Implements the concatenation operator. +X */ +Xstatic char * +Xregbranch(flagp) +Xint *flagp; +X{ +X register char *ret; +X register char *chain; +X register char *latest; +X int flags; +X +X *flagp = WORST; /* Tentatively. */ +X +X ret = regnode(BRANCH); +X chain = NULL; +X while (*regparse != '\0' && *regparse != '|' && *regparse != ')') { +X latest = regpiece(&flags); +X if (latest == NULL) +X return(NULL); +X *flagp |= flags&HASWIDTH; +X if (chain == NULL) /* First piece. */ +X *flagp |= flags&SPSTART; +X else +X regtail(chain, latest); +X chain = latest; +X } +X if (chain == NULL) /* Loop ran zero times. */ +X (void) regnode(NOTHING); +X +X return(ret); +X} +X +X/* +X - regpiece - something followed by possible [*+?] +X * +X * Note that the branching code sequences used for ? and the general cases +X * of * and + are somewhat optimized: they use the same NOTHING node as +X * both the endmarker for their branch list and the body of the last branch. +X * It might seem that this node could be dispensed with entirely, but the +X * endmarker role is not redundant. +X */ +Xstatic char * +Xregpiece(flagp) +Xint *flagp; +X{ +X register char *ret; +X register char op; +X register char *next; +X int flags; +X +X ret = regatom(&flags); +X if (ret == NULL) +X return(NULL); +X +X op = *regparse; +X if (!ISMULT(op)) { +X *flagp = flags; +X return(ret); +X } +X +X if (!(flags&HASWIDTH) && op != '?') +X FAIL("*+ operand could be empty"); +X *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH); +X +X if (op == '*' && (flags&SIMPLE)) +X reginsert(STAR, ret); +X else if (op == '*') { +X /* Emit x* as (x&|), where & means "self". */ +X reginsert(BRANCH, ret); /* Either x */ +X regoptail(ret, regnode(BACK)); /* and loop */ +X regoptail(ret, ret); /* back */ +X regtail(ret, regnode(BRANCH)); /* or */ +X regtail(ret, regnode(NOTHING)); /* null. */ +X } else if (op == '+' && (flags&SIMPLE)) +X reginsert(PLUS, ret); +X else if (op == '+') { +X /* Emit x+ as x(&|), where & means "self". */ +X next = regnode(BRANCH); /* Either */ +X regtail(ret, next); +X regtail(regnode(BACK), ret); /* loop back */ +X regtail(next, regnode(BRANCH)); /* or */ +X regtail(ret, regnode(NOTHING)); /* null. */ +X } else if (op == '?') { +X /* Emit x? as (x|) */ +X reginsert(BRANCH, ret); /* Either x */ +X regtail(ret, regnode(BRANCH)); /* or */ +X next = regnode(NOTHING); /* null. */ +X regtail(ret, next); +X regoptail(ret, next); +X } +X regparse++; +X if (ISMULT(*regparse)) +X FAIL("nested *?+"); +X +X return(ret); +X} +X +X/* +X - regatom - the lowest level +X * +X * Optimization: gobbles an entire sequence of ordinary characters so that +X * it can turn them into a single node, which is smaller to store and +X * faster to run. Backslashed characters are exceptions, each becoming a +X * separate node; the code is simpler that way and it's not worth fixing. +X */ +Xstatic char * +Xregatom(flagp) +Xint *flagp; +X{ +X register char *ret; +X int flags; +X +X *flagp = WORST; /* Tentatively. */ +X +X switch (*regparse++) { +X case '^': +X ret = regnode(BOL); +X break; +X case '$': +X ret = regnode(EOL); +X break; +X case '.': +X ret = regnode(ANY); +X *flagp |= HASWIDTH|SIMPLE; +X break; +X case '[': { +X register int class; +X register int classend; +X +X if (*regparse == '^') { /* Complement of range. */ +X ret = regnode(ANYBUT); +X regparse++; +X } else +X ret = regnode(ANYOF); +X if (*regparse == ']' || *regparse == '-') +X regc(*regparse++); +X while (*regparse != '\0' && *regparse != ']') { +X if (*regparse == '-') { +X regparse++; +X if (*regparse == ']' || *regparse == '\0') +X regc('-'); +X else { +X class = UCHARAT(regparse-2)+1; +X classend = UCHARAT(regparse); +X if (class > classend+1) +X FAIL("invalid [] range"); +X for (; class <= classend; class++) +X regc(class); +X regparse++; +X } +X } else +X regc(*regparse++); +X } +X regc('\0'); +X if (*regparse != ']') +X FAIL("unmatched []"); +X regparse++; +X *flagp |= HASWIDTH|SIMPLE; +X } +X break; +X case '(': +X ret = reg(1, &flags); +X if (ret == NULL) +X return(NULL); +X *flagp |= flags&(HASWIDTH|SPSTART); +X break; +X case '\0': +X case '|': +X case ')': +X FAIL("internal urp"); /* Supposed to be caught earlier. */ +X break; +X case '?': +X case '+': +X case '*': +X FAIL("?+* follows nothing"); +X break; +X case '\\': +X if (*regparse == '\0') +X FAIL("trailing \\"); +X ret = regnode(EXACTLY); +X#ifdef MULTILINE +X if (*regparse == 'n') { +X regc('\n'); +X regparse++; +X regnl++; +X } +X else +X#endif +X regc(*regparse++); +X regc('\0'); +X *flagp |= HASWIDTH|SIMPLE; +X break; +X default: { +X register int len; +X register char ender; +X +X regparse--; +X len = strcspn(regparse, META); +X if (len <= 0) +X FAIL("internal disaster"); +X ender = *(regparse+len); +X if (len > 1 && ISMULT(ender)) +X len--; /* Back off clear of ?+* operand. */ +X *flagp |= HASWIDTH; +X if (len == 1) +X *flagp |= SIMPLE; +X ret = regnode(EXACTLY); +X while (len > 0) { +X#ifdef MULTILINE +X if (*regparse == '\n') +X regnl++; +X#endif +X regc(*regparse++); +X len--; +X } +X regc('\0'); +X } +X break; +X } +X +X return(ret); +X} +X +X/* +X - regnode - emit a node +X */ +Xstatic char * /* Location. */ +Xregnode(op) +Xchar op; +X{ +X register char *ret; +X register char *ptr; +X +X ret = regcode; +X if (ret == ®dummy) { +X regsize += 3; +X return(ret); +X } +X +X ptr = ret; +X *ptr++ = op; +X *ptr++ = '\0'; /* Null "next" pointer. */ +X *ptr++ = '\0'; +X regcode = ptr; +X +X return(ret); +X} +X +X/* +X - regc - emit (if appropriate) a byte of code +X */ +Xstatic void +Xregc(b) +Xchar b; +X{ +X if (regcode != ®dummy) +X *regcode++ = b; +X else +X regsize++; +X} +X +X/* +X - reginsert - insert an operator in front of already-emitted operand +X * +X * Means relocating the operand. +X */ +Xstatic void +Xreginsert(op, opnd) +Xchar op; +Xchar *opnd; +X{ +X register char *src; +X register char *dst; +X register char *place; +X +X if (regcode == ®dummy) { +X regsize += 3; +X return; +X } +X +X src = regcode; +X regcode += 3; +X dst = regcode; +X while (src > opnd) +X *--dst = *--src; +X +X place = opnd; /* Op node, where operand used to be. */ +X *place++ = op; +X *place++ = '\0'; +X *place++ = '\0'; +X} +X +X/* +X - regtail - set the next-pointer at the end of a node chain +X */ +Xstatic void +Xregtail(p, val) +Xchar *p; +Xchar *val; +X{ +X register char *scan; +X register char *temp; +X register int offset; +X +X if (p == ®dummy) +X return; +X +X /* Find last node. */ +X scan = p; +X for (;;) { +X temp = regnext(scan); +X if (temp == NULL) +X break; +X scan = temp; +X } +X +X if (OP(scan) == BACK) +X offset = scan - val; +X else +X offset = val - scan; +X *(scan+1) = (offset>>8)&0377; +X *(scan+2) = offset&0377; +X} +X +X/* +X - regoptail - regtail on operand of first argument; nop if operandless +X */ +Xstatic void +Xregoptail(p, val) +Xchar *p; +Xchar *val; +X{ +X /* "Operandless" and "op != BRANCH" are synonymous in practice. */ +X if (p == NULL || p == ®dummy || OP(p) != BRANCH) +X return; +X regtail(OPERAND(p), val); +X} +X +X/* +X * regexec and friends +X */ +X +X/* +X * Global work variables for regexec(). +X */ +Xstatic char *reginput; /* String-input pointer. */ +Xstatic char *regbol; /* Beginning of input, for ^ check. */ +Xstatic char **regstartp; /* Pointer to startp array. */ +Xstatic char **regendp; /* Ditto for endp. */ +X +X/* +X * Forwards. +X */ +XSTATIC int regtry(); +XSTATIC int regmatch(); +XSTATIC int regrepeat(); +X +X#ifdef DEBUG +Xint regnarrate = 0; +Xvoid regdump(); +XSTATIC char *regprop(); +X#endif +X +X/* +X - regexec - match a regexp against a string +X */ +Xint +Xregexec(prog, string) +Xregister regexp *prog; +Xregister char *string; +X{ +X register char *s; +X extern char *strchr(); +X +X /* Be paranoid... */ +X if (prog == NULL || string == NULL) { +X regerror("NULL parameter"); +X return(0); +X } +X +X#ifdef MULTILINE +X /* Check for \n in string, and if so, call the more general routine. */ +X if (strchr(string, '\n') != NULL) +X return reglexec(prog, string, 0); +X#endif +X +X /* Check validity of program. */ +X if (UCHARAT(prog->program) != MAGIC) { +X regerror("corrupted program"); +X return(0); +X } +X +X /* If there is a "must appear" string, look for it. */ +X if (prog->regmust != NULL) { +X s = string; +X while ((s = strchr(s, prog->regmust[0])) != NULL) { +X if (strncmp(s, prog->regmust, prog->regmlen) == 0) +X break; /* Found it. */ +X s++; +X } +X if (s == NULL) /* Not present. */ +X return(0); +X } +X +X /* Mark beginning of line for ^ . */ +X regbol = string; +X +X /* Simplest case: anchored match need be tried only once. */ +X if (prog->reganch) +X return(regtry(prog, string)); +X +X /* Messy cases: unanchored match. */ +X s = string; +X if (prog->regstart != '\0') +X /* We know what char it must start with. */ +X while ((s = strchr(s, prog->regstart)) != NULL) { +X if (regtry(prog, s)) +X return(1); +X s++; +X } +X else +X /* We don't -- general case. */ +X do { +X if (regtry(prog, s)) +X return(1); +X } while (*s++ != '\0'); +X +X /* Failure. */ +X return(0); +X} +X +X#ifdef MULTILINE +X/* +X - reglexec - match a regexp against a long string buffer, starting at offset +X */ +Xint +Xreglexec(prog, string, offset) +Xregister regexp *prog; +Xregister char *string; +X{ +X register char *s; +X extern char *strchr(); +X +X /* Be paranoid... */ +X if (prog == NULL || string == NULL) { +X regerror("NULL parameter"); +X return(0); +X } +X +X /* Check validity of program. */ +X if (UCHARAT(prog->program) != MAGIC) { +X regerror("corrupted program"); +X return(0); +X } +X +X /* (Don't look for "must appear" string -- string can be long.) */ +X +X /* Mark beginning of line for ^ . */ +X regbol = string; +X +X /* Apply offset. +X Assume 0 <= offset <= strlen(string), but don't check, +X as string can be long. */ +X s= string + offset; +X +X /* Anchored match need be tried only at line starts. */ +X if (prog->reganch) { +X while (!regtry(prog, s)) { +X s = strchr(s, '\n'); +X if (s == NULL) +X return(0); +X s++; +X } +X return(1); +X } +X +X /* Messy cases: unanchored match. */ +X if (prog->regstart != '\0') +X /* We know what char it must start with. */ +X while ((s = strchr(s, prog->regstart)) != NULL) { +X if (regtry(prog, s)) +X return(1); +X s++; +X } +X else +X /* We don't -- general case. */ +X do { +X if (regtry(prog, s)) +X return(1); +X } while (*s++ != '\0'); +X +X /* Failure. */ +X return(0); +X} +X#endif +X +X/* +X - regtry - try match at specific point +X */ +Xstatic int /* 0 failure, 1 success */ +Xregtry(prog, string) +Xregexp *prog; +Xchar *string; +X{ +X register int i; +X register char **sp; +X register char **ep; +X +X reginput = string; +X regstartp = prog->startp; +X regendp = prog->endp; +X +X sp = prog->startp; +X ep = prog->endp; +X for (i = NSUBEXP; i > 0; i--) { +X *sp++ = NULL; +X *ep++ = NULL; +X } +X if (regmatch(prog->program + 1)) { +X prog->startp[0] = string; +X prog->endp[0] = reginput; +X return(1); +X } else +X return(0); +X} +X +X/* +X - regmatch - main matching routine +X * +X * Conceptually the strategy is simple: check to see whether the current +X * node matches, call self recursively to see whether the rest matches, +X * and then act accordingly. In practice we make some effort to avoid +X * recursion, in particular by going through "ordinary" nodes (that don't +X * need to know whether the rest of the match failed) by a loop instead of +X * by recursion. +X */ +Xstatic int /* 0 failure, 1 success */ +Xregmatch(prog) +Xchar *prog; +X{ +X register char *scan; /* Current node. */ +X char *next; /* Next node. */ +X extern char *strchr(); +X +X scan = prog; +X#ifdef DEBUG +X if (scan != NULL && regnarrate) +X fprintf(stderr, "%s(\n", regprop(scan)); +X#endif +X while (scan != NULL) { +X#ifdef DEBUG +X if (regnarrate) +X fprintf(stderr, "%s...\n", regprop(scan)); +X#endif +X next = regnext(scan); +X +X switch (OP(scan)) { +X case BOL: +X#ifdef MULTILINE +X if (!(reginput == regbol || +X reginput > regbol && *(reginput-1) == '\n')) +X#else +X if (reginput != regbol) +X#endif +X return(0); +X break; +X case EOL: +X#ifdef MULTILINE +X if (*reginput != '\0' && *reginput != '\n') +X#else +X if (*reginput != '\0') +X#endif +X return(0); +X break; +X case ANY: +X#ifdef MULTILINE +X if (*reginput == '\0' || *reginput == '\n') +X#else +X if (*reginput == '\0') +X#endif +X return(0); +X reginput++; +X break; +X case EXACTLY: { +X register int len; +X register char *opnd; +X +X opnd = OPERAND(scan); +X /* Inline the first character, for speed. */ +X if (*opnd != *reginput) +X return(0); +X len = strlen(opnd); +X if (len > 1 && strncmp(opnd, reginput, len) != 0) +X return(0); +X reginput += len; +X } +X break; +X case ANYOF: +X if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == NULL) +X return(0); +X reginput++; +X break; +X case ANYBUT: +X#ifdef MULTILINE +X if (*reginput == '\0' || *reginput == '\n' || +X strchr(OPERAND(scan), *reginput) != NULL) +X#else +X if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != NULL) +X#endif +X return(0); +X reginput++; +X break; +X case NOTHING: +X break; +X case BACK: +X break; +X case OPEN+1: +X case OPEN+2: +X case OPEN+3: +X case OPEN+4: +X case OPEN+5: +X case OPEN+6: +X case OPEN+7: +X case OPEN+8: +X case OPEN+9: { +X register int no; +X register char *save; +X +X no = OP(scan) - OPEN; +X save = reginput; +X +X if (regmatch(next)) { +X /* +X * Don't set startp if some later +X * invocation of the same parentheses +X * already has. +X */ +X if (regstartp[no] == NULL) +X regstartp[no] = save; +X return(1); +X } else +X return(0); +X } +X break; +X case CLOSE+1: +X case CLOSE+2: +X case CLOSE+3: +X case CLOSE+4: +X case CLOSE+5: +X case CLOSE+6: +X case CLOSE+7: +X case CLOSE+8: +X case CLOSE+9: { +X register int no; +X register char *save; +X +X no = OP(scan) - CLOSE; +X save = reginput; +X +X if (regmatch(next)) { +X /* +X * Don't set endp if some later +X * invocation of the same parentheses +X * already has. +X */ +X if (regendp[no] == NULL) +X regendp[no] = save; +X return(1); +X } else +X return(0); +X } +X break; +X case BRANCH: { +X register char *save; +X +X if (OP(next) != BRANCH) /* No choice. */ +X next = OPERAND(scan); /* Avoid recursion. */ +X else { +X do { +X save = reginput; +X if (regmatch(OPERAND(scan))) +X return(1); +X reginput = save; +X scan = regnext(scan); +X } while (scan != NULL && OP(scan) == BRANCH); +X return(0); +X /* NOTREACHED */ +X } +X } +X break; +X case STAR: +X case PLUS: { +X register char nextch; +X register int no; +X register char *save; +X register int min; +X +X /* +X * Lookahead to avoid useless match attempts +X * when we know what character comes next. +X */ +X nextch = '\0'; +X if (OP(next) == EXACTLY) +X nextch = *OPERAND(next); +X min = (OP(scan) == STAR) ? 0 : 1; +X save = reginput; +X no = regrepeat(OPERAND(scan)); +X while (no >= min) { +X /* If it could work, try it. */ +X if (nextch == '\0' || *reginput == nextch) +X if (regmatch(next)) +X return(1); +X /* Couldn't or didn't -- back up. */ +X no--; +X reginput = save + no; +X } +X return(0); +X } +X break; +X case END: +X return(1); /* Success! */ +X break; +X default: +X regerror("memory corruption"); +X return(0); +X break; +X } +X +X scan = next; +X } +X +X /* +X * We get here only if there's trouble -- normally "case END" is +X * the terminating point. +X */ +X regerror("corrupted pointers"); +X return(0); +X} +X +X/* +X - regrepeat - repeatedly match something simple, report how many +X */ +Xstatic int +Xregrepeat(p) +Xchar *p; +X{ +X register int count = 0; +X register char *scan; +X register char *opnd; +X#ifdef MULTILINE +X register char *eol; +X#endif +X +X scan = reginput; +X opnd = OPERAND(p); +X switch (OP(p)) { +X case ANY: +X#ifdef MULTILINE +X if ((eol = strchr(scan, '\n')) != NULL) { +X count += eol - scan; +X scan = eol; +X break; +X } +X#endif +X count = strlen(scan); +X scan += count; +X break; +X case EXACTLY: +X while (*opnd == *scan) { +X count++; +X scan++; +X } +X break; +X case ANYOF: +X while (*scan != '\0' && strchr(opnd, *scan) != NULL) { +X count++; +X scan++; +X } +X break; +X case ANYBUT: +X#ifdef MULTILINE +X while (*scan != '\0' && *scan != '\n' && +X strchr(opnd, *scan) == NULL) { +X#else +X while (*scan != '\0' && strchr(opnd, *scan) == NULL) { +X#endif +X count++; +X scan++; +X } +X break; +X default: /* Oh dear. Called inappropriately. */ +X regerror("internal foulup"); +X count = 0; /* Best compromise. */ +X break; +X } +X reginput = scan; +X +X return(count); +X} +X +X/* +X - regnext - dig the "next" pointer out of a node +X */ +Xstatic char * +Xregnext(p) +Xregister char *p; +X{ +X register int offset; +X +X if (p == ®dummy) +X return(NULL); +X +X offset = NEXT(p); +X if (offset == 0) +X return(NULL); +X +X if (OP(p) == BACK) +X return(p-offset); +X else +X return(p+offset); +X} +X +X#ifdef DEBUG +X +XSTATIC char *regprop(); +X +X/* +X - regdump - dump a regexp onto stdout in vaguely comprehensible form +X */ +Xvoid +Xregdump(r) +Xregexp *r; +X{ +X register char *s; +X register char op = EXACTLY; /* Arbitrary non-END op. */ +X register char *next; +X extern char *strchr(); +X +X +X s = r->program + 1; +X while (op != END) { /* While that wasn't END last time... */ +X op = OP(s); +X printf("%2d%s", (int)(s-r->program), regprop(s)); /* Where, what. */ +X next = regnext(s); +X if (next == NULL) /* Next ptr. */ +X printf("(0)"); +X else +X printf("(%d)", (int)((s-r->program)+(next-s))); +X s += 3; +X if (op == ANYOF || op == ANYBUT || op == EXACTLY) { +X /* Literal string, where present. */ +X while (*s != '\0') { +X#ifdef MULTILINE +X if (*s == '\n') +X printf("\\n"); +X else +X#endif +X putchar(*s); +X s++; +X } +X s++; +X } +X putchar('\n'); +X } +X +X /* Header fields of interest. */ +X if (r->regstart != '\0') +X printf("start `%c' ", r->regstart); +X if (r->reganch) +X printf("anchored "); +X if (r->regmust != NULL) +X printf("must have \"%s\"", r->regmust); +X printf("\n"); +X} +X +X/* +X - regprop - printable representation of opcode +X */ +Xstatic char * +Xregprop(op) +Xchar *op; +X{ +X register char *p; +X static char buf[50]; +X +X (void) strcpy(buf, ":"); +X +X switch (OP(op)) { +X case BOL: +X p = "BOL"; +X break; +X case EOL: +X p = "EOL"; +X break; +X case ANY: +X p = "ANY"; +X break; +X case ANYOF: +X p = "ANYOF"; +X break; +X case ANYBUT: +X p = "ANYBUT"; +X break; +X case BRANCH: +X p = "BRANCH"; +X break; +X case EXACTLY: +X p = "EXACTLY"; +X break; +X case NOTHING: +X p = "NOTHING"; +X break; +X case BACK: +X p = "BACK"; +X break; +X case END: +X p = "END"; +X break; +X case OPEN+1: +X case OPEN+2: +X case OPEN+3: +X case OPEN+4: +X case OPEN+5: +X case OPEN+6: +X case OPEN+7: +X case OPEN+8: +X case OPEN+9: +X sprintf(buf+strlen(buf), "OPEN%d", (int)(OP(op)-OPEN)); +X p = NULL; +X break; +X case CLOSE+1: +X case CLOSE+2: +X case CLOSE+3: +X case CLOSE+4: +X case CLOSE+5: +X case CLOSE+6: +X case CLOSE+7: +X case CLOSE+8: +X case CLOSE+9: +X sprintf(buf+strlen(buf), "CLOSE%d", (int)(OP(op)-CLOSE)); +X p = NULL; +X break; +X case STAR: +X p = "STAR"; +X break; +X case PLUS: +X p = "PLUS"; +X break; +X default: +X regerror("corrupted opcode"); +X break; +X } +X if (p != NULL) +X (void) strcat(buf, p); +X return(buf); +X} +X#endif +X +X/* +X * The following is provided for those people who do not have strcspn() in +X * their C libraries. They should get off their butts and do something +X * about it; at least one public-domain implementation of those (highly +X * useful) string routines has been published on Usenet. +X */ +X#ifdef STRCSPN +X/* +X * strcspn - find length of initial segment of s1 consisting entirely +X * of characters not from s2 +X */ +X +Xstatic int +Xstrcspn(s1, s2) +Xchar *s1; +Xchar *s2; +X{ +X register char *scan1; +X register char *scan2; +X register int count; +X +X count = 0; +X for (scan1 = s1; *scan1 != '\0'; scan1++) { +X for (scan2 = s2; *scan2 != '\0';) /* ++ moved down. */ +X if (*scan1 == *scan2++) +X return(count); +X count++; +X } +X return(count); +X} +X#endif +EOF +fi +echo 'Part 05 out of 21 of pack.out complete.' +exit 0 |