mirror of
https://github.com/freebsd/freebsd-src
synced 2024-10-02 22:54:52 +00:00
Remove trailing whitespace.
This commit is contained in:
parent
709e8f9ae1
commit
4399be3cbd
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=8858
|
@ -8,7 +8,7 @@ DPADD= ${LIBCURSES} ${LIBTERMCAP}
|
|||
LDADD= -lcurses -ltermcap
|
||||
HIDEGAME=hidegame
|
||||
|
||||
beforeinstall:
|
||||
beforeinstall:
|
||||
install -c -o ${BINOWN} -g ${BINGRP} -m 444 ${.CURDIR}/gnuchess.book \
|
||||
${DESTDIR}/usr/share/games
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
# RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:05 $
|
||||
# $Source: /a/cvs/386BSD/src/gnu/chess/Xchess/Makefile,v $
|
||||
# RCS Info: $Revision: 1.2 $ on $Date: 1994/01/07 11:10:39 $
|
||||
# $Source: /home/ncvs/src/gnu/games/chess/Xchess/Makefile,v $
|
||||
# Copyright (c) 1985 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
#
|
||||
# Makefile for xchess.
|
||||
|
@ -95,7 +95,7 @@ reopt: all
|
|||
|
||||
install: all
|
||||
|
||||
source: $(SOURCE)
|
||||
source: $(SOURCE)
|
||||
|
||||
tags: $(ALLFILES)
|
||||
ctags -w -t *.c *.h > /dev/null 2>&1
|
||||
|
@ -123,7 +123,7 @@ depend: $(SOURCE)
|
|||
echo '$$r makedep' >>eddep
|
||||
echo 'w' >>eddep
|
||||
ed - Makefile < eddep
|
||||
rm eddep makedep
|
||||
rm eddep makedep
|
||||
echo '# DEPENDENCIES MUST END AT END OF FILE' >> Makefile
|
||||
echo '# IF YOU PUT STUFF HERE IT WILL GO AWAY' >> Makefile
|
||||
echo '# see make depend above' >> Makefile
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.2 $ on $Date: 86/11/23 17:17:04 $
|
||||
* $Source: /users/faustus/xchess/RCS/XCircle.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:12 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/XCircle.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -143,7 +143,7 @@ XCircle(win, x, y, rad, start, end, width, height, pixel, func, planes)
|
|||
verts[0].flags |= VertexStartClosed;
|
||||
verts[j].x = verts[0].x;
|
||||
verts[j].y = verts[0].y;
|
||||
verts[j].flags = (verts[0].flags & ~VertexStartClosed) |
|
||||
verts[j].flags = (verts[0].flags & ~VertexStartClosed) |
|
||||
VertexEndClosed;
|
||||
for (i = 0; i < 15; i++) {
|
||||
if (dp)
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/23 17:17:15 $
|
||||
* $Source: /users/faustus/xchess/RCS/board.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:08 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/board.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -164,12 +164,12 @@ board_move(b, m)
|
|||
if (m->piece.color == WHITE) {
|
||||
if (m->fromx == 0)
|
||||
b->white_cant_castle_q = true;
|
||||
else if (m->fromx == 7)
|
||||
else if (m->fromx == 7)
|
||||
b->white_cant_castle_k = true;
|
||||
} else {
|
||||
if (m->fromx == 0)
|
||||
b->black_cant_castle_q = true;
|
||||
else if (m->fromx == 7)
|
||||
else if (m->fromx == 7)
|
||||
b->black_cant_castle_k = true;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/26 12:09:41 $
|
||||
* $Source: /users/faustus/xchess/RCS/button.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:15 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/button.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -52,7 +52,7 @@ static struct but {
|
|||
{ "Reset", 0, 80, 108, 29, RESTART } ,
|
||||
{ "Save", 109, 80, 108, 29, SAVE } ,
|
||||
#define EASY_OFFSET 8
|
||||
{ "Switch", 219, 80, 108, 29, SWITCH }
|
||||
{ "Switch", 219, 80, 108, 29, SWITCH }
|
||||
/* { "NoEasy", 219, 80, 108, 29, EASY }*/
|
||||
} ;
|
||||
static int easy = 1;
|
||||
|
@ -69,7 +69,7 @@ button_draw(win)
|
|||
XSetLineAttributes(win->display, DefaultGC(win->display, 0),
|
||||
BORDER_WIDTH, LineSolid, CapButt,
|
||||
JoinMiter);
|
||||
|
||||
|
||||
XDrawLine(win->display, win->buttonwin,
|
||||
DefaultGC(win->display, 0),
|
||||
0, 29, BUTTON_WIDTH, 29);
|
||||
|
@ -85,9 +85,9 @@ button_draw(win)
|
|||
|
||||
XSetFont(win->display, DefaultGC(win->display, 0), win->large->fid);
|
||||
XSetForeground(win->display, DefaultGC(win->display, 0),
|
||||
win->textcolor.pixel);
|
||||
win->textcolor.pixel);
|
||||
XSetBackground(win->display, DefaultGC(win->display, 0),
|
||||
win->textback.pixel);
|
||||
win->textback.pixel);
|
||||
|
||||
for (i = 0; i < numbuts; i++) {
|
||||
x = (buts[i].width -
|
||||
|
@ -219,7 +219,7 @@ button_service(win, event)
|
|||
|
||||
case SAVE:
|
||||
if (saveflag) {
|
||||
message_add(win,
|
||||
message_add(win,
|
||||
"Game is already being logged in file '", true);
|
||||
message_add(win, record_file, true);
|
||||
message_add(win, "'.\n", true);
|
||||
|
@ -248,12 +248,12 @@ button_service(win, event)
|
|||
return;
|
||||
}
|
||||
}
|
||||
message_add(win1,
|
||||
message_add(win1,
|
||||
"Clock stopped.\nHit 'Pause' again to restart.\n",
|
||||
false);
|
||||
if (!oneboard)
|
||||
message_add(win2,
|
||||
"Clock stopped.\nHit 'Pause' again to restart.\n",
|
||||
message_add(win2,
|
||||
"Clock stopped.\nHit 'Pause' again to restart.\n",
|
||||
false);
|
||||
clock_started = false;
|
||||
} else {
|
||||
|
@ -320,7 +320,7 @@ button_service(win, event)
|
|||
win->textcolor.pixel);
|
||||
XSetBackground(win->display,
|
||||
DefaultGC(win->display, 0),
|
||||
win->textback.pixel);
|
||||
win->textback.pixel);
|
||||
|
||||
XDrawImageString(win->display,
|
||||
win->buttonwin,
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/26 12:09:47 $
|
||||
* $Source: /users/faustus/xchess/RCS/clock.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:08 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/clock.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -59,7 +59,7 @@ clock_draw(win, col)
|
|||
Window w = ((col == WHITE) ? win->wclockwin : win->bclockwin);
|
||||
|
||||
/* Draw a clock face and the hands. */
|
||||
XCircle(w, x, y, rad, 0.0, 0.0, 1, 1, win->textcolor.pixel, GXcopy,
|
||||
XCircle(w, x, y, rad, 0.0, 0.0, 1, 1, win->textcolor.pixel, GXcopy,
|
||||
AllPlanes);
|
||||
rad -= 8;
|
||||
|
||||
|
@ -112,7 +112,7 @@ clock_update()
|
|||
lastwhite = lastblack = now;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if (white_running) {
|
||||
whiteseconds += now - lastwhite;
|
||||
lastwhite = now;
|
||||
|
@ -198,7 +198,7 @@ dohands(win, col)
|
|||
{
|
||||
int cx = CLOCK_WIDTH / 2, cy = CLOCK_WIDTH / 2;
|
||||
double *h = (col == WHITE) ? win->whitehands : win->blackhands;
|
||||
Window w = (col == WHITE) ? win->wclockwin : win->bclockwin;
|
||||
Window w = (col == WHITE) ? win->wclockwin : win->bclockwin;
|
||||
long secs = (col == WHITE) ? whiteseconds : blackseconds;
|
||||
int rad, x, y, i;
|
||||
|
||||
|
@ -272,11 +272,11 @@ hilight(win, col, on)
|
|||
BORDER_WIDTH, LineSolid, CapButt, JoinMiter);
|
||||
XSetFont(win->display, DefaultGC(win->display, 0),
|
||||
win->large->fid);
|
||||
|
||||
|
||||
XDrawLine(win->display, w, DefaultGC(win->display, 0),
|
||||
0, CLOCK_HEIGHT - 26,
|
||||
CLOCK_WIDTH, CLOCK_HEIGHT - 26);
|
||||
|
||||
|
||||
XDrawImageString(win->display, w, DefaultGC(win->display, 0),
|
||||
(CLOCK_WIDTH - x) / 2, CLOCK_HEIGHT,
|
||||
s, strlen(s));
|
||||
|
|
|
@ -19,8 +19,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/23 17:17:32 $
|
||||
* $Source: /users/faustus/xchess/RCS/control.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:11 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/control.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -154,7 +154,7 @@ button_released(event, win)
|
|||
thismove->type = QCASTLE;
|
||||
else
|
||||
thismove->type = MOVE;
|
||||
|
||||
|
||||
/* Now check the en-passant case... */
|
||||
if ((thismove->type == MOVE) && ((thismove->tox == thismove->fromx + 1)
|
||||
|| (thismove->tox == thismove->fromx - 1)) &&
|
||||
|
@ -278,7 +278,7 @@ screen_move(m)
|
|||
win_drawpiece(&m->piece, m->toy, m->tox, BLACK);
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case KCASTLE:
|
||||
if (m->piece.color == WHITE) {
|
||||
win_erasepiece(7, 4, WHITE);
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.3 $ on $Date: 86/11/26 12:09:54 $
|
||||
* $Source: /users/faustus/xchess/RCS/jail.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:12 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/jail.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -82,7 +82,7 @@ jail_draw(win)
|
|||
win->textcolor.pixel);
|
||||
XSetBackground(win->display, DefaultGC(win->display, 0),
|
||||
win->textback.pixel);
|
||||
|
||||
|
||||
XDrawImageString(win->display, win->jailwin,
|
||||
DefaultGC(win->display, 0),
|
||||
(JAIL_WIDTH - i) / 2, 20, JAIL_HEADER,
|
||||
|
@ -96,7 +96,7 @@ jail_draw(win)
|
|||
FillSolid);
|
||||
XSetFunction(win->display, DefaultGC(win->display, 0),
|
||||
GXcopy);
|
||||
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
if (pos[i]) {
|
||||
p.color = WHITE;
|
||||
|
@ -105,7 +105,7 @@ jail_draw(win)
|
|||
tmpPM = XCreateBitmapFromData(win->display,
|
||||
win->jailwin, bits,
|
||||
32, 32);
|
||||
|
||||
|
||||
XCopyPlane(win->display, tmpPM, win->jailwin,
|
||||
DefaultGC(win->display, 0),
|
||||
0, 0, 32, 32,
|
||||
|
@ -127,7 +127,7 @@ jail_draw(win)
|
|||
tmpPM = XCreateBitmapFromData(win->display,
|
||||
win->jailwin, bits,
|
||||
32, 32);
|
||||
|
||||
|
||||
XCopyPlane(win->display, tmpPM, win->jailwin,
|
||||
DefaultGC(win->display, 0),
|
||||
0, 0, 32, 32,
|
||||
|
@ -151,7 +151,7 @@ jail_add(p)
|
|||
int i = piecepos(p, false);
|
||||
char *bits;
|
||||
Pixmap tmpPM;
|
||||
|
||||
|
||||
pos[i] = true;
|
||||
|
||||
bits = bitsget(p);
|
||||
|
@ -165,14 +165,14 @@ jail_add(p)
|
|||
tmpPM = XCreateBitmapFromData(win1->display,
|
||||
win1->jailwin, bits,
|
||||
32, 32);
|
||||
|
||||
|
||||
XCopyPlane(win1->display, tmpPM, win1->jailwin,
|
||||
DefaultGC(win1->display, 0),
|
||||
0, 0, 32, 32,
|
||||
5 + (i % 8) * 32, ((i >= 16) ? 30 : 25) + (i / 8) * 32,
|
||||
1);
|
||||
XFreePixmap(win1->display, tmpPM);
|
||||
|
||||
|
||||
if (!oneboard) {
|
||||
XSetState(win2->display, DefaultGC(win2->display, 0),
|
||||
win2->blackpiece.pixel,
|
||||
|
@ -184,7 +184,7 @@ jail_add(p)
|
|||
tmpPM = XCreateBitmapFromData(win2->display,
|
||||
win2->jailwin, bits,
|
||||
32, 32);
|
||||
|
||||
|
||||
XCopyPlane(win2->display, tmpPM, win2->jailwin,
|
||||
DefaultGC(win2->display, 0),
|
||||
0, 0, 32, 32,
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/26 12:10:22 $
|
||||
* $Source: /users/faustus/xchess/RCS/message.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:14 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/message.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -38,7 +38,7 @@ void
|
|||
message_init(win)
|
||||
windata *win;
|
||||
{
|
||||
TxtGrab(win->display, win->messagewin, "xchess", win->medium,
|
||||
TxtGrab(win->display, win->messagewin, "xchess", win->medium,
|
||||
win->textback.pixel, win->textcolor.pixel,
|
||||
win->cursorcolor.pixel);
|
||||
TxtAddFont(win->display, win->messagewin, 1, win->large, win->textcolor.pixel);
|
||||
|
|
|
@ -19,8 +19,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.2 $ on $Date: 86/11/23 17:17:59 $
|
||||
* $Source: /users/faustus/xchess/RCS/parse.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:06 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/parse.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -71,7 +71,7 @@ load_game(file)
|
|||
message_add(win1, buf, false);
|
||||
if (!oneboard)
|
||||
message_add(win2, buf, false);
|
||||
|
||||
|
||||
fgets(buf, BSIZE, fp);
|
||||
if (eq(buf, "\tenglish\n"))
|
||||
eflag = true;
|
||||
|
@ -106,7 +106,7 @@ load_game(file)
|
|||
|
||||
while (fgets(buf, BSIZE, fp))
|
||||
message_add(win1, buf, false);
|
||||
|
||||
|
||||
fclose(fp);
|
||||
|
||||
return;
|
||||
|
@ -179,7 +179,7 @@ parse_file(fp, b, english)
|
|||
* name followed by a row number. If the column name is kr, kn, kb, k, q,
|
||||
* qb, qn, or qr, then the row number is according to the english system,
|
||||
* or if it is a-h then it is according to the international system.
|
||||
*
|
||||
*
|
||||
*** As of now the spec must include the position.
|
||||
*/
|
||||
|
||||
|
@ -380,7 +380,7 @@ if (debug) fprintf(stderr, "(alg) parsing %s\n", buf);
|
|||
else if ((m->piece.type == KING) && (m->fromy == m->toy) &&
|
||||
(m->fromx == 4) && (m->tox == 2))
|
||||
m->type = QCASTLE;
|
||||
|
||||
|
||||
return (m);
|
||||
}
|
||||
|
||||
|
|
|
@ -20,9 +20,9 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.2 $ on $Date: 86/11/26 12:10:38 $
|
||||
* $Source: /users/faustus/xchess/RCS/popup.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:13 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/popup.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* faustus@cad.berkeley.edu, ucbvax!faustus
|
||||
* Permission is granted to modify and re-distribute this code in any manner
|
||||
* as long as this notice is preserved. All standard disclaimers apply.
|
||||
|
@ -75,7 +75,7 @@ pop_question(win, text)
|
|||
XMapRaised(win->display, w);
|
||||
XSetFont(win->display, DefaultGC(win->display, 0),
|
||||
win->medium->fid);
|
||||
|
||||
|
||||
for (i = 0, s = text; i < nlines - 4; i++) {
|
||||
for (t = s, j = 0; *t && (*t != '\n'); t++, j++)
|
||||
;
|
||||
|
|
|
@ -20,7 +20,7 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.2 $ on $Date: 1994/01/07 11:10:40 $
|
||||
/* RCS Info: $Revision: 1.3 $ on $Date: 1994/11/04 02:11:30 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/program.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
|
@ -62,7 +62,7 @@ program_init(name)
|
|||
sprintf (moves, "%d", movesperunit);
|
||||
if (proghost)
|
||||
execl("/usr/ucb/rsh", "rsh", proghost, name,
|
||||
moves, time,
|
||||
moves, time,
|
||||
(char *) NULL);
|
||||
else
|
||||
execl(name, name, moves, time, (char *) NULL);
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.4 $ on $Date: 86/11/23 17:18:20 $
|
||||
* $Source: /users/faustus/xchess/RCS/record.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:09 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/record.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -56,7 +56,7 @@ record_init(win)
|
|||
i = XTextWidth(win->medium, RECORD_HEADER,
|
||||
sizeof(RECORD_HEADER) - 1);
|
||||
i = (40 * win->small->max_bounds.width - i *
|
||||
win->medium->max_bounds.width) /
|
||||
win->medium->max_bounds.width) /
|
||||
win->medium->max_bounds.width / 2;
|
||||
TxtGrab(win->display, win->recwin, "xchess", win->small, win->textback.pixel,
|
||||
win->textcolor.pixel, win->cursorcolor.pixel);
|
||||
|
@ -64,7 +64,7 @@ record_init(win)
|
|||
for (; i > 0; i++)
|
||||
TxtWriteStr(win->display, win->recwin, " ");
|
||||
TxtWriteStr(win->display, win->recwin, RECORD_HEADER);
|
||||
|
||||
|
||||
if (saveflag) {
|
||||
if (!(backup = fopen(record_file, "w"))) {
|
||||
perror(record_file);
|
||||
|
@ -72,7 +72,7 @@ record_init(win)
|
|||
} else {
|
||||
fprintf(backup, "X Chess -- %s\n", datestring());
|
||||
if (dispname2)
|
||||
fprintf(backup, "\tWhite on %s, black on %s\n",
|
||||
fprintf(backup, "\tWhite on %s, black on %s\n",
|
||||
dispname1, dispname2);
|
||||
else
|
||||
fprintf(backup, "\tGame played on %s\n",
|
||||
|
@ -136,7 +136,7 @@ record_save()
|
|||
}
|
||||
fprintf(fp, "X Chess -- %s\n", datestring());
|
||||
if (dispname2)
|
||||
fprintf(fp, "\tWhite on %s, black on %s\n",
|
||||
fprintf(fp, "\tWhite on %s, black on %s\n",
|
||||
dispname1, dispname2);
|
||||
else
|
||||
fprintf(fp, "\tGame played on %s\n", dispname1);
|
||||
|
@ -201,7 +201,7 @@ record_back()
|
|||
s = buf;
|
||||
for (i = 0; *s != '\0'; i++)
|
||||
*s++ = ''; /* control H, backspace */
|
||||
|
||||
|
||||
TxtWriteStr(win1->display, win1->recwin, buf);
|
||||
if (!oneboard) {
|
||||
TxtWriteStr(win2->display, win2->recwin, buf);
|
||||
|
@ -279,9 +279,9 @@ movestring(m)
|
|||
sprintf(buf, "something strange");
|
||||
break;
|
||||
}
|
||||
if ((m->piece.type == PAWN) && (((m->piece.color == BLACK) &&
|
||||
if ((m->piece.type == PAWN) && (((m->piece.color == BLACK) &&
|
||||
(m->toy == 7)) || ((m->piece.color == WHITE) &&
|
||||
(m->toy == 0))))
|
||||
(m->toy == 0))))
|
||||
strcat(buf, "(Q)");
|
||||
|
||||
#ifdef smartass
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* A Scrollable Text Output Window
|
||||
*
|
||||
* David Harrison
|
||||
* David Harrison
|
||||
* University of California, Berkeley
|
||||
* 1986
|
||||
*
|
||||
|
@ -204,7 +204,7 @@ int bg, fg, cur; /* Background, foreground, and cursor colors */
|
|||
XWindowAttributes winInfo; /* Window information */
|
||||
int index;
|
||||
XGCValues gc_val;
|
||||
|
||||
|
||||
if (textWindows == (XAssocTable *) 0) {
|
||||
textWindows = XCreateAssocTable(32);
|
||||
if (textWindows == (XAssocTable *) 0) return(0);
|
||||
|
@ -259,7 +259,7 @@ int bg, fg, cur; /* Background, foreground, and cursor colors */
|
|||
winInfo.width - BARSIZE,
|
||||
0, BARSIZE - (2*BARBORDER),
|
||||
winInfo.height - (2*BARBORDER),
|
||||
BARBORDER,
|
||||
BARBORDER,
|
||||
fg, bg);
|
||||
XSelectInput(display, newWin->scrollBar, ExposureMask|ButtonReleaseMask);
|
||||
XMapRaised(display, newWin->scrollBar);
|
||||
|
@ -302,7 +302,7 @@ int bg, fg, cur; /* Background, foreground, and cursor colors */
|
|||
newWin->fontGC[index] = 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Initialize size of first line */
|
||||
newWin->txtBuffer[0]->lineHeight = newWin->theFonts[0].ascent +
|
||||
newWin->theFonts[0].descent;
|
||||
|
@ -391,7 +391,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
(startPos > 0) && (textInfo->mainBuffer[startPos] != '\n');
|
||||
startPos--)
|
||||
/* null loop body */;
|
||||
|
||||
|
||||
/* Clear out the old line start array */
|
||||
for (index = 0; index < textInfo->numLines; index++) {
|
||||
InitLine(textInfo->txtBuffer[index]);
|
||||
|
@ -411,7 +411,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
curfont = 0;
|
||||
for (index = 0; index < textInfo->bufSpot; index++) {
|
||||
theChar = bufptr[index] & CHARMASK;
|
||||
|
||||
|
||||
if ((bufptr[index] & FONTMASK) != curfont) {
|
||||
int newFontNum, heightDiff;
|
||||
|
||||
|
@ -503,7 +503,7 @@ int newColor; /* Color of font */
|
|||
struct txtWin *textInfo;
|
||||
int redrawFlag;
|
||||
XGCValues gc_val;
|
||||
|
||||
|
||||
if ((fontNumber < 0) || (fontNumber >= MAXFONTS)) return 0;
|
||||
if ((textInfo = (struct txtWin *)
|
||||
XLookUpAssoc(display, textWindows, (XID) textWin)) == 0)
|
||||
|
@ -518,7 +518,7 @@ int newColor; /* Color of font */
|
|||
gc_val.plane_mask = AllPlanes;
|
||||
gc_val.graphics_exposures = 1;
|
||||
gc_val.function = GXcopy;
|
||||
|
||||
|
||||
if (textInfo->fontGC[fontNumber] != 0)
|
||||
{
|
||||
XChangeGC(display, textInfo->fontGC[fontNumber],
|
||||
|
@ -532,7 +532,7 @@ int newColor; /* Color of font */
|
|||
GCFunction |
|
||||
GCPlaneMask |
|
||||
GCGraphicsExposures,
|
||||
&gc_val);
|
||||
&gc_val);
|
||||
|
||||
|
||||
redrawFlag = (textInfo->theFonts[fontNumber].fid != 0) &&
|
||||
|
@ -622,7 +622,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
if (bottom == textInfo->h-(2*BARBORDER)) bottom--;
|
||||
|
||||
XFillRectangle(display, textInfo->scrollBar,
|
||||
textInfo->bgGC,
|
||||
textInfo->bgGC,
|
||||
0, 0, BARSIZE, top-1);
|
||||
#ifdef __FreeBSD__
|
||||
XFillRectangle(display, textInfo->scrollBar,
|
||||
|
@ -648,7 +648,7 @@ Display *display;
|
|||
Window w;
|
||||
/*
|
||||
* This routine clears a scrollable text window. It resets the current
|
||||
* writing position to the upper left hand corner of the screen.
|
||||
* writing position to the upper left hand corner of the screen.
|
||||
* NOTE: THIS ALSO CLEARS THE CONTENTS OF THE TEXT WINDOW BUFFER AND
|
||||
* RESETS THE SCROLL BAR. Returns 0 if the window is not a text window.
|
||||
* This should be used *instead* of XClear.
|
||||
|
@ -674,7 +674,7 @@ Window w;
|
|||
textInfo->endLine = 0;
|
||||
textInfo->curLine = 0;
|
||||
textInfo->curX = 0;
|
||||
textInfo->curY = YPADDING + textInfo->theFonts[textInfo->curFont].ascent
|
||||
textInfo->curY = YPADDING + textInfo->theFonts[textInfo->curFont].ascent
|
||||
+ textInfo->theFonts[textInfo->curFont].descent;
|
||||
|
||||
textInfo->bottomSpace = textInfo->h - YPADDING -
|
||||
|
@ -1119,7 +1119,7 @@ int ypos; /* Y position for line */
|
|||
curX += CharSize(textInfo, lineIndex, index);
|
||||
glyph++;
|
||||
}
|
||||
|
||||
|
||||
/* Flush out the glyphs */
|
||||
XFillRectangle(display, textInfo->mainWindow,
|
||||
textInfo->bgGC,
|
||||
|
@ -1191,7 +1191,7 @@ int flagWord; /* DODISP or nothing */
|
|||
if ((textInfo->curY + thisLine->lineHeight + heightDiff +
|
||||
INTERLINE) > textInfo->h)
|
||||
{
|
||||
/*
|
||||
/*
|
||||
* General approach: "unscroll" the last line up
|
||||
* and then call ScrollDown to do the right thing.
|
||||
*/
|
||||
|
@ -1210,7 +1210,7 @@ int flagWord; /* DODISP or nothing */
|
|||
(textInfo->bottomSpace + INTERLINE +
|
||||
thisLine->lineHeight);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
/* Just update bottom space */
|
||||
textInfo->bottomSpace -= heightDiff;
|
||||
|
@ -1251,7 +1251,7 @@ register char *str; /* 0 terminated string */
|
|||
* - A new font can be chosen using the sequence '^F<digit>' where
|
||||
* <digit> is 0-7. The directive will be ignored if
|
||||
* there is no font in the specified slot.
|
||||
* Returns 0 if something went wrong.
|
||||
* Returns 0 if something went wrong.
|
||||
*/
|
||||
{
|
||||
register int fontIndex;
|
||||
|
@ -1260,7 +1260,7 @@ register char *str; /* 0 terminated string */
|
|||
|
||||
if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)) == 0)
|
||||
return 0;
|
||||
|
||||
|
||||
/* See if screen needs to be updated */
|
||||
if (textInfo->flagWord & SCREENWRONG) {
|
||||
TxtRepaint(display, textInfo->mainWindow);
|
||||
|
@ -1292,7 +1292,7 @@ register char *str; /* 0 terminated string */
|
|||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Inline code for handling normal character case */
|
||||
if ((*str >= LOWCHAR) && (*str <= HIGHCHAR)) {
|
||||
register XFontStruct *thisFont;
|
||||
|
@ -1324,21 +1324,21 @@ register char *str; /* 0 terminated string */
|
|||
HandleNewLine(display, textInfo, DODISP | NONEWLINE);
|
||||
thisLine = textInfo->txtBuffer[textInfo->curLine];
|
||||
}
|
||||
|
||||
|
||||
/* Ready to draw character */
|
||||
XDrawString(display, textInfo->mainWindow,
|
||||
DEFAULT_GC,
|
||||
DEFAULT_GC,
|
||||
textInfo->curX += charWidth,
|
||||
textInfo->curY + thisLine->lineHeight,
|
||||
textInfo->curY + thisLine->lineHeight,
|
||||
str, 1);
|
||||
|
||||
|
||||
/* Append character onto main buffer */
|
||||
if (textInfo->bufSpot >= textInfo->bufAlloc)
|
||||
/* Make room for more characters */
|
||||
ExpandBuffer(textInfo);
|
||||
textInfo->mainBuffer[(textInfo->bufSpot)++] =
|
||||
(textInfo->curFont << FONTSHIFT) | (*str);
|
||||
|
||||
|
||||
/* Update the line start array */
|
||||
thisLine->lineLength += 1;
|
||||
thisLine->lineWidth += charWidth;
|
||||
|
@ -1384,7 +1384,7 @@ register char *str; /* NULL terminated string */
|
|||
if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)
|
||||
) == 0)
|
||||
return 0;
|
||||
|
||||
|
||||
for ( /* str is ok */ ; (*str != 0) ; str++) {
|
||||
/* Check to see if we are waiting on a font */
|
||||
if (textInfo->flagWord & FONTNUMWAIT) {
|
||||
|
@ -1402,7 +1402,7 @@ register char *str; /* NULL terminated string */
|
|||
register XFontStruct *thisFont;
|
||||
register struct txtLine *thisLine;
|
||||
register int charWidth;
|
||||
|
||||
|
||||
/* Determine size of character */
|
||||
thisFont = &(textInfo->theFonts[textInfo->curFont]);
|
||||
|
||||
|
@ -1429,7 +1429,7 @@ register char *str; /* NULL terminated string */
|
|||
ExpandBuffer(textInfo);
|
||||
textInfo->mainBuffer[(textInfo->bufSpot)++] =
|
||||
(textInfo->curFont << FONTSHIFT) | (*str);
|
||||
|
||||
|
||||
/* Update the line start array */
|
||||
thisLine->lineLength += 1;
|
||||
thisLine->lineWidth += charWidth;
|
||||
|
@ -1455,7 +1455,7 @@ Display *display;
|
|||
Window w;
|
||||
/*
|
||||
* Repaints the given scrollable text window. The routine repaints
|
||||
* the entire window. For handling exposure events, the TxtFilter
|
||||
* the entire window. For handling exposure events, the TxtFilter
|
||||
* routine should be used.
|
||||
*/
|
||||
{
|
||||
|
@ -1589,7 +1589,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
0, textInfo->h - textInfo->bottomSpace,
|
||||
textInfo->w, textInfo->bottomSpace);
|
||||
#endif
|
||||
|
||||
|
||||
UpdateExposures(display, textInfo);
|
||||
UpdateScroll(display, textInfo);
|
||||
|
||||
|
@ -1774,7 +1774,7 @@ XEvent *evt;
|
|||
return 0;
|
||||
|
||||
if ((textInfo = (struct txtWin *)
|
||||
XLookUpAssoc(display, textWindows, (XID) w)) == 0)
|
||||
XLookUpAssoc(display, textWindows, (XID) w)) == 0)
|
||||
return 0;
|
||||
|
||||
/* Determine whether it's main window or not */
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* A Scrollable Text Output Window
|
||||
*
|
||||
* David Harrison
|
||||
* David Harrison
|
||||
* University of California, Berkeley
|
||||
* 1986
|
||||
*
|
||||
|
@ -204,7 +204,7 @@ int bg, fg, cur; /* Background, foreground, and cursor colors */
|
|||
XWindowAttributes winInfo; /* Window information */
|
||||
int index;
|
||||
XGCValues gc_val;
|
||||
|
||||
|
||||
if (textWindows == (XAssocTable *) 0) {
|
||||
textWindows = XCreateAssocTable(32);
|
||||
if (textWindows == (XAssocTable *) 0) return(0);
|
||||
|
@ -259,7 +259,7 @@ int bg, fg, cur; /* Background, foreground, and cursor colors */
|
|||
winInfo.width - BARSIZE,
|
||||
0, BARSIZE - (2*BARBORDER),
|
||||
winInfo.height - (2*BARBORDER),
|
||||
BARBORDER,
|
||||
BARBORDER,
|
||||
fg, bg);
|
||||
XSelectInput(display, newWin->scrollBar, ExposureMask|ButtonReleaseMask);
|
||||
XMapRaised(display, newWin->scrollBar);
|
||||
|
@ -302,7 +302,7 @@ int bg, fg, cur; /* Background, foreground, and cursor colors */
|
|||
newWin->fontGC[index] = 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Initialize size of first line */
|
||||
newWin->txtBuffer[0]->lineHeight = newWin->theFonts[0].ascent +
|
||||
newWin->theFonts[0].descent;
|
||||
|
@ -391,7 +391,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
(startPos > 0) && (textInfo->mainBuffer[startPos] != '\n');
|
||||
startPos--)
|
||||
/* null loop body */;
|
||||
|
||||
|
||||
/* Clear out the old line start array */
|
||||
for (index = 0; index < textInfo->numLines; index++) {
|
||||
InitLine(textInfo->txtBuffer[index]);
|
||||
|
@ -411,7 +411,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
curfont = 0;
|
||||
for (index = 0; index < textInfo->bufSpot; index++) {
|
||||
theChar = bufptr[index] & CHARMASK;
|
||||
|
||||
|
||||
if ((bufptr[index] & FONTMASK) != curfont) {
|
||||
int newFontNum, heightDiff;
|
||||
|
||||
|
@ -503,7 +503,7 @@ int newColor; /* Color of font */
|
|||
struct txtWin *textInfo;
|
||||
int redrawFlag;
|
||||
XGCValues gc_val;
|
||||
|
||||
|
||||
if ((fontNumber < 0) || (fontNumber >= MAXFONTS)) return 0;
|
||||
if ((textInfo = (struct txtWin *)
|
||||
XLookUpAssoc(display, textWindows, (XID) textWin)) == 0)
|
||||
|
@ -518,7 +518,7 @@ int newColor; /* Color of font */
|
|||
gc_val.plane_mask = AllPlanes;
|
||||
gc_val.graphics_exposures = 1;
|
||||
gc_val.function = GXcopy;
|
||||
|
||||
|
||||
if (textInfo->fontGC[fontNumber] != 0)
|
||||
{
|
||||
XChangeGC(display, textInfo->fontGC[fontNumber],
|
||||
|
@ -532,7 +532,7 @@ int newColor; /* Color of font */
|
|||
GCFunction |
|
||||
GCPlaneMask |
|
||||
GCGraphicsExposures,
|
||||
&gc_val);
|
||||
&gc_val);
|
||||
|
||||
|
||||
redrawFlag = (textInfo->theFonts[fontNumber].fid != 0) &&
|
||||
|
@ -622,7 +622,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
if (bottom == textInfo->h-(2*BARBORDER)) bottom--;
|
||||
|
||||
XFillRectangle(display, textInfo->scrollBar,
|
||||
textInfo->bgGC,
|
||||
textInfo->bgGC,
|
||||
0, 0, BARSIZE, top-1);
|
||||
XFillRectangle(display, textInfo->scrollBar,
|
||||
DEFAULT_GC, top, BARSIZE - (2*BARBORDER) - 2,
|
||||
|
@ -642,7 +642,7 @@ Display *display;
|
|||
Window w;
|
||||
/*
|
||||
* This routine clears a scrollable text window. It resets the current
|
||||
* writing position to the upper left hand corner of the screen.
|
||||
* writing position to the upper left hand corner of the screen.
|
||||
* NOTE: THIS ALSO CLEARS THE CONTENTS OF THE TEXT WINDOW BUFFER AND
|
||||
* RESETS THE SCROLL BAR. Returns 0 if the window is not a text window.
|
||||
* This should be used *instead* of XClear.
|
||||
|
@ -668,7 +668,7 @@ Window w;
|
|||
textInfo->endLine = 0;
|
||||
textInfo->curLine = 0;
|
||||
textInfo->curX = 0;
|
||||
textInfo->curY = YPADDING + textInfo->theFonts[textInfo->curFont].ascent
|
||||
textInfo->curY = YPADDING + textInfo->theFonts[textInfo->curFont].ascent
|
||||
+ textInfo->theFonts[textInfo->curFont].descent;
|
||||
|
||||
textInfo->bottomSpace = textInfo->h - YPADDING -
|
||||
|
@ -1106,7 +1106,7 @@ int ypos; /* Y position for line */
|
|||
curX += CharSize(textInfo, lineIndex, index);
|
||||
glyph++;
|
||||
}
|
||||
|
||||
|
||||
/* Flush out the glyphs */
|
||||
XFillRectangle(display, textInfo->mainWindow,
|
||||
textInfo->bgGC,
|
||||
|
@ -1178,7 +1178,7 @@ int flagWord; /* DODISP or nothing */
|
|||
if ((textInfo->curY + thisLine->lineHeight + heightDiff +
|
||||
INTERLINE) > textInfo->h)
|
||||
{
|
||||
/*
|
||||
/*
|
||||
* General approach: "unscroll" the last line up
|
||||
* and then call ScrollDown to do the right thing.
|
||||
*/
|
||||
|
@ -1197,7 +1197,7 @@ int flagWord; /* DODISP or nothing */
|
|||
(textInfo->bottomSpace + INTERLINE +
|
||||
thisLine->lineHeight);
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
/* Just update bottom space */
|
||||
textInfo->bottomSpace -= heightDiff;
|
||||
|
@ -1238,7 +1238,7 @@ register char *str; /* 0 terminated string */
|
|||
* - A new font can be chosen using the sequence '^F<digit>' where
|
||||
* <digit> is 0-7. The directive will be ignored if
|
||||
* there is no font in the specified slot.
|
||||
* Returns 0 if something went wrong.
|
||||
* Returns 0 if something went wrong.
|
||||
*/
|
||||
{
|
||||
register int fontIndex;
|
||||
|
@ -1247,7 +1247,7 @@ register char *str; /* 0 terminated string */
|
|||
|
||||
if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)) == 0)
|
||||
return 0;
|
||||
|
||||
|
||||
/* See if screen needs to be updated */
|
||||
if (textInfo->flagWord & SCREENWRONG) {
|
||||
TxtRepaint(display, textInfo->mainWindow);
|
||||
|
@ -1279,7 +1279,7 @@ register char *str; /* 0 terminated string */
|
|||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Inline code for handling normal character case */
|
||||
if ((*str >= LOWCHAR) && (*str <= HIGHCHAR)) {
|
||||
register XFontStruct *thisFont;
|
||||
|
@ -1311,21 +1311,21 @@ register char *str; /* 0 terminated string */
|
|||
HandleNewLine(display, textInfo, DODISP | NONEWLINE);
|
||||
thisLine = textInfo->txtBuffer[textInfo->curLine];
|
||||
}
|
||||
|
||||
|
||||
/* Ready to draw character */
|
||||
XDrawString(display, textInfo->mainWindow,
|
||||
DEFAULT_GC,
|
||||
DEFAULT_GC,
|
||||
textInfo->curX += charWidth,
|
||||
textInfo->curY + thisLine->lineHeight,
|
||||
textInfo->curY + thisLine->lineHeight,
|
||||
str, 1);
|
||||
|
||||
|
||||
/* Append character onto main buffer */
|
||||
if (textInfo->bufSpot >= textInfo->bufAlloc)
|
||||
/* Make room for more characters */
|
||||
ExpandBuffer(textInfo);
|
||||
textInfo->mainBuffer[(textInfo->bufSpot)++] =
|
||||
(textInfo->curFont << FONTSHIFT) | (*str);
|
||||
|
||||
|
||||
/* Update the line start array */
|
||||
thisLine->lineLength += 1;
|
||||
thisLine->lineWidth += charWidth;
|
||||
|
@ -1371,7 +1371,7 @@ register char *str; /* NULL terminated string */
|
|||
if ((textInfo = (struct txtWin *) XLookUpAssoc(display, textWindows, (XID) w)
|
||||
) == 0)
|
||||
return 0;
|
||||
|
||||
|
||||
for ( /* str is ok */ ; (*str != 0) ; str++) {
|
||||
/* Check to see if we are waiting on a font */
|
||||
if (textInfo->flagWord & FONTNUMWAIT) {
|
||||
|
@ -1389,7 +1389,7 @@ register char *str; /* NULL terminated string */
|
|||
register XFontStruct *thisFont;
|
||||
register struct txtLine *thisLine;
|
||||
register int charWidth;
|
||||
|
||||
|
||||
/* Determine size of character */
|
||||
thisFont = &(textInfo->theFonts[textInfo->curFont]);
|
||||
|
||||
|
@ -1416,7 +1416,7 @@ register char *str; /* NULL terminated string */
|
|||
ExpandBuffer(textInfo);
|
||||
textInfo->mainBuffer[(textInfo->bufSpot)++] =
|
||||
(textInfo->curFont << FONTSHIFT) | (*str);
|
||||
|
||||
|
||||
/* Update the line start array */
|
||||
thisLine->lineLength += 1;
|
||||
thisLine->lineWidth += charWidth;
|
||||
|
@ -1442,7 +1442,7 @@ Display *display;
|
|||
Window w;
|
||||
/*
|
||||
* Repaints the given scrollable text window. The routine repaints
|
||||
* the entire window. For handling exposure events, the TxtFilter
|
||||
* the entire window. For handling exposure events, the TxtFilter
|
||||
* routine should be used.
|
||||
*/
|
||||
{
|
||||
|
@ -1570,7 +1570,7 @@ struct txtWin *textInfo; /* Text window information */
|
|||
XClearArea(display, textInfo->mainWindow,
|
||||
0, textInfo->h - textInfo->bottomSpace,
|
||||
textInfo->w, textInfo->bottomSpace);
|
||||
|
||||
|
||||
UpdateExposures(display, textInfo);
|
||||
UpdateScroll(display, textInfo);
|
||||
|
||||
|
@ -1755,7 +1755,7 @@ XEvent *evt;
|
|||
return 0;
|
||||
|
||||
if ((textInfo = (struct txtWin *)
|
||||
XLookUpAssoc(display, textWindows, (XID) w)) == 0)
|
||||
XLookUpAssoc(display, textWindows, (XID) w)) == 0)
|
||||
return 0;
|
||||
|
||||
/* Determine whether it's main window or not */
|
||||
|
|
|
@ -20,7 +20,7 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.2 $ on $Date: 1994/01/07 11:10:42 $
|
||||
/* RCS Info: $Revision: 1.3 $ on $Date: 1994/11/04 02:11:33 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/std.c,v $
|
||||
* Copyright (c) 1985 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
*
|
||||
|
@ -62,7 +62,7 @@ copy(str)
|
|||
char *str;
|
||||
{
|
||||
char *p, *tmalloc();
|
||||
|
||||
|
||||
p = tmalloc(strlen(str) + 1);
|
||||
strcpy(p, str);
|
||||
return(p);
|
||||
|
@ -90,7 +90,7 @@ substring(sub, str)
|
|||
}
|
||||
|
||||
/* Malloc num bytes and initialize to zero. Fatal error if the space can't
|
||||
* be malloc'd.
|
||||
* be malloc'd.
|
||||
*/
|
||||
|
||||
char *
|
||||
|
@ -375,7 +375,7 @@ setenv(name, value)
|
|||
environ = xx;
|
||||
} else
|
||||
xx = environ;
|
||||
|
||||
|
||||
xx[i] = tmalloc(strlen(name) + strlen(value) + 2);
|
||||
sprintf(xx[i], "%s=%s", name, value);
|
||||
return;
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.3 $ on $Date: 86/11/23 17:18:35 $
|
||||
* $Source: /users/faustus/xchess/RCS/valid.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:08 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/valid.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -49,10 +49,10 @@ valid_move(m, b)
|
|||
board_move(&tb, m);
|
||||
if (ischeck(&tb, m->piece.color))
|
||||
return (false);
|
||||
|
||||
|
||||
if (ischeck(&tb, ((m->piece.color == WHITE) ? BLACK : WHITE)))
|
||||
m->check = true;
|
||||
|
||||
|
||||
return (true);
|
||||
}
|
||||
|
||||
|
@ -66,7 +66,7 @@ couldmove(m, b)
|
|||
switch (m->type) {
|
||||
case KCASTLE:
|
||||
if ((m->piece.color == WHITE) && (b->white_cant_castle_k) ||
|
||||
(m->piece.color == BLACK) &&
|
||||
(m->piece.color == BLACK) &&
|
||||
(b->black_cant_castle_k))
|
||||
return (false);
|
||||
if ((b->square[m->fromy][5].color != NONE) ||
|
||||
|
@ -78,7 +78,7 @@ couldmove(m, b)
|
|||
|
||||
case QCASTLE:
|
||||
if ((m->piece.color == WHITE) && (b->white_cant_castle_q) ||
|
||||
(m->piece.color == BLACK) &&
|
||||
(m->piece.color == BLACK) &&
|
||||
(b->black_cant_castle_q))
|
||||
return (false);
|
||||
if ((b->square[m->fromy][1].color != NONE) ||
|
||||
|
@ -129,7 +129,7 @@ couldmove(m, b)
|
|||
*/
|
||||
if (m->enpassant) {
|
||||
if (b->square[(m->piece.color == WHITE)
|
||||
? 3 : 4][m->tox].color ==
|
||||
? 3 : 4][m->tox].color ==
|
||||
((m->piece.color == WHITE) ?
|
||||
BLACK : WHITE))
|
||||
break;
|
||||
|
|
|
@ -19,8 +19,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.5 $ on $Date: 86/11/26 12:11:15 $
|
||||
* $Source: /users/faustus/xchess/RCS/window.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:08 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/window.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -89,7 +89,7 @@ win_setup(disp1, disp2)
|
|||
win2->flipped = true;
|
||||
win_drawboard(win2);
|
||||
}
|
||||
|
||||
|
||||
return(true);
|
||||
}
|
||||
|
||||
|
@ -199,7 +199,7 @@ win_drawpiece(p, y, x, wnum)
|
|||
XSetState(win->display, DefaultGC(win->display, 0),
|
||||
BlackPixel(win->display, 0),
|
||||
WhitePixel(win->display, 0), GXcopy, AllPlanes);
|
||||
|
||||
|
||||
tmpPM = XCreateBitmapFromData(win->display, win->boardwin,
|
||||
shade_bits, SQUARE_WIDTH, SQUARE_HEIGHT);
|
||||
|
||||
|
@ -209,7 +209,7 @@ win_drawpiece(p, y, x, wnum)
|
|||
y * (SQUARE_HEIGHT + BORDER_WIDTH), 1);
|
||||
|
||||
XFreePixmap(win->display, tmpPM);
|
||||
|
||||
|
||||
XSetFunction(win->display, DefaultGC(win->display, 0),
|
||||
GXandInverted);
|
||||
maskPM = XCreateBitmapFromData(win->display, win->boardwin,
|
||||
|
@ -268,16 +268,16 @@ win_drawpiece(p, y, x, wnum)
|
|||
gc.background = win->blacksquare.pixel;
|
||||
|
||||
gc.font = win->small->fid;
|
||||
|
||||
|
||||
XChangeGC(win->display, DefaultGC(win->display, 0),
|
||||
GCForeground | GCBackground | GCFont, &gc);
|
||||
|
||||
|
||||
if (!x) {
|
||||
sprintf(buf, " %d", SIZE - y);
|
||||
XDrawImageString(win->display, win->boardwin,
|
||||
DefaultGC(win->display, 0),
|
||||
1, (y + 1) * (SQUARE_HEIGHT +
|
||||
BORDER_WIDTH) - BORDER_WIDTH +
|
||||
1, (y + 1) * (SQUARE_HEIGHT +
|
||||
BORDER_WIDTH) - BORDER_WIDTH +
|
||||
win->small->max_bounds.ascent - 1, buf, 2);
|
||||
}
|
||||
if (y == SIZE - 1) {
|
||||
|
@ -285,7 +285,7 @@ win_drawpiece(p, y, x, wnum)
|
|||
XDrawImageString(win->display, win->boardwin,
|
||||
DefaultGC(win->display, 0),
|
||||
x * (SQUARE_WIDTH + BORDER_WIDTH) + 1,
|
||||
SIZE * (SQUARE_HEIGHT + BORDER_WIDTH) - BORDER_WIDTH +
|
||||
SIZE * (SQUARE_HEIGHT + BORDER_WIDTH) - BORDER_WIDTH +
|
||||
win->small->max_bounds.ascent - 1, buf, 1);
|
||||
}
|
||||
}
|
||||
|
@ -301,12 +301,12 @@ win_erasepiece(y, x, wnum)
|
|||
char buf[BSIZE];
|
||||
XGCValues gc;
|
||||
Pixmap tmpPM;
|
||||
|
||||
|
||||
if (oneboard || (wnum == win1->color))
|
||||
win = win1;
|
||||
else
|
||||
win = win2;
|
||||
|
||||
|
||||
if (win->flipped) {
|
||||
y = SIZE - y - 1;
|
||||
x = SIZE - x - 1;
|
||||
|
@ -354,16 +354,16 @@ win_erasepiece(y, x, wnum)
|
|||
gc.background = win->blacksquare.pixel;
|
||||
|
||||
gc.font = win->small->fid;
|
||||
|
||||
|
||||
XChangeGC(win->display, DefaultGC(win->display, 0),
|
||||
GCForeground | GCBackground | GCFont, &gc);
|
||||
|
||||
|
||||
if (!x) {
|
||||
sprintf(buf, " %d", SIZE - y);
|
||||
XDrawImageString(win->display, win->boardwin,
|
||||
DefaultGC(win->display, 0),
|
||||
1, (y + 1) * (SQUARE_HEIGHT +
|
||||
BORDER_WIDTH) - BORDER_WIDTH +
|
||||
1, (y + 1) * (SQUARE_HEIGHT +
|
||||
BORDER_WIDTH) - BORDER_WIDTH +
|
||||
win->small->max_bounds.ascent - 1, buf, 2);
|
||||
}
|
||||
if (y == SIZE - 1) {
|
||||
|
@ -371,11 +371,11 @@ win_erasepiece(y, x, wnum)
|
|||
XDrawImageString(win->display, win->boardwin,
|
||||
DefaultGC(win->display, 0),
|
||||
x * (SQUARE_WIDTH + BORDER_WIDTH) + 1,
|
||||
SIZE * (SQUARE_HEIGHT + BORDER_WIDTH) - BORDER_WIDTH +
|
||||
SIZE * (SQUARE_HEIGHT + BORDER_WIDTH) - BORDER_WIDTH +
|
||||
win->small->max_bounds.ascent - 1, buf, 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
return;
|
||||
}
|
||||
|
@ -392,7 +392,7 @@ win_flash(m, wnum)
|
|||
win = win1;
|
||||
else
|
||||
win = win2;
|
||||
|
||||
|
||||
if (win->flipped) {
|
||||
sx = SIZE - m->fromx - 1;
|
||||
sy = SIZE - m->fromy - 1;
|
||||
|
@ -417,7 +417,7 @@ win_flash(m, wnum)
|
|||
DefaultGC(win->display, 0),
|
||||
sx, sy, ex, ey);
|
||||
}
|
||||
|
||||
|
||||
XSetFunction(win->display, DefaultGC(win->display, 0), GXcopy);
|
||||
return;
|
||||
}
|
||||
|
@ -598,7 +598,7 @@ win_redraw(win, event)
|
|||
x2 = SIZE - x1 - 1;
|
||||
}
|
||||
|
||||
for (i = x1; i <= x2; i++)
|
||||
for (i = x1; i <= x2; i++)
|
||||
for (j = y1; j <= y2; j++) {
|
||||
if (chessboard->square[j][i].color == NONE)
|
||||
win_erasepiece(j, i, WHITE);
|
||||
|
@ -613,7 +613,7 @@ win_redraw(win, event)
|
|||
j, i, BLACK);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -627,11 +627,11 @@ setup(dispname, win)
|
|||
Cursor cur;
|
||||
extern char *program, *recfile;
|
||||
XSizeHints xsizes;
|
||||
|
||||
|
||||
|
||||
if (!(win->display = XOpenDisplay(dispname)))
|
||||
return (false);
|
||||
|
||||
|
||||
|
||||
/* Now get boolean defaults... */
|
||||
if ((s = XGetDefault(win->display, program, "noisy")) && eq(s, "on"))
|
||||
|
@ -646,13 +646,13 @@ setup(dispname, win)
|
|||
quickflag = true;
|
||||
if ((s = XGetDefault(win->display, program, "flash")) && eq(s, "on"))
|
||||
win_flashmove = true;
|
||||
|
||||
|
||||
/* ... numeric variables ... */
|
||||
if (s = XGetDefault(win->display, program, "numflashes"))
|
||||
num_flashes = atoi(s);
|
||||
if (s = XGetDefault(win->display, program, "flashsize"))
|
||||
flash_size = atoi(s);
|
||||
|
||||
|
||||
/* ... and strings. */
|
||||
if (s = XGetDefault(win->display, program, "progname"))
|
||||
progname = s;
|
||||
|
@ -683,7 +683,7 @@ setup(dispname, win)
|
|||
|
||||
if ((DisplayPlanes(win->display, 0) == 1) || bnwflag)
|
||||
win->bnw = true;
|
||||
|
||||
|
||||
/* Allocate colors... */
|
||||
if (win->bnw) {
|
||||
win->blackpiece.pixel = BlackPixel (win->display, 0);
|
||||
|
@ -699,64 +699,64 @@ setup(dispname, win)
|
|||
} else {
|
||||
if (!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
black_piece_color, &win->blackpiece) ||
|
||||
black_piece_color, &win->blackpiece) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
white_piece_color, &win->whitepiece) ||
|
||||
white_piece_color, &win->whitepiece) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
black_square_color, &win->blacksquare) ||
|
||||
black_square_color, &win->blacksquare) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
white_square_color, &win->whitesquare) ||
|
||||
white_square_color, &win->whitesquare) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
border_color, &win->border) ||
|
||||
border_color, &win->border) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
text_color, &win->textcolor) ||
|
||||
text_color, &win->textcolor) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
text_back, &win->textback) ||
|
||||
text_back, &win->textback) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
error_text, &win->errortext) ||
|
||||
error_text, &win->errortext) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
player_text, &win->playertext) ||
|
||||
player_text, &win->playertext) ||
|
||||
!XParseColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
cursor_color, &win->cursorcolor) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->blackpiece) ||
|
||||
&win->blackpiece) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->whitepiece) ||
|
||||
&win->whitepiece) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->blacksquare) ||
|
||||
&win->blacksquare) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->whitesquare) ||
|
||||
&win->whitesquare) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->border) ||
|
||||
&win->border) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->textcolor) ||
|
||||
&win->textcolor) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->textback) ||
|
||||
&win->textback) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->errortext) ||
|
||||
&win->errortext) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->playertext) ||
|
||||
&win->playertext) ||
|
||||
!XAllocColor(win->display,
|
||||
DefaultColormap(win->display, 0),
|
||||
&win->cursorcolor))
|
||||
&win->cursorcolor))
|
||||
fprintf(stderr, "Can't get colors...\n");
|
||||
}
|
||||
|
||||
|
@ -773,17 +773,17 @@ setup(dispname, win)
|
|||
NULL)
|
||||
fprintf(stderr, "Can't get large font...\n");
|
||||
|
||||
|
||||
|
||||
/* Create the windows... */
|
||||
|
||||
win->basewin =
|
||||
XCreateSimpleWindow(win->display,DefaultRootWindow(win->display),
|
||||
BASE_XPOS, BASE_YPOS,
|
||||
BASE_XPOS, BASE_YPOS,
|
||||
BASE_WIDTH, BASE_HEIGHT, 0,
|
||||
BlackPixel(win->display, 0),
|
||||
WhitePixel(win->display, 0));
|
||||
WhitePixel(win->display, 0));
|
||||
win->boardwin = XCreateSimpleWindow(win->display,win->basewin,
|
||||
BOARD_XPOS, BOARD_YPOS,
|
||||
BOARD_XPOS, BOARD_YPOS,
|
||||
BOARD_WIDTH, BOARD_HEIGHT,
|
||||
BORDER_WIDTH,
|
||||
win->border.pixel,
|
||||
|
@ -819,7 +819,7 @@ setup(dispname, win)
|
|||
BUTTON_WIDTH, BUTTON_HEIGHT,
|
||||
BORDER_WIDTH, win->border.pixel,
|
||||
win->textback.pixel);
|
||||
|
||||
|
||||
/* Let's define an icon... */
|
||||
win->iconpixmap = XCreatePixmapFromBitmapData(win->display,
|
||||
win->basewin, icon_bits,
|
||||
|
@ -835,7 +835,7 @@ setup(dispname, win)
|
|||
XSetStandardProperties(win->display, win->basewin,
|
||||
program, program, win->iconpixmap,
|
||||
0, NULL, &xsizes);
|
||||
|
||||
|
||||
bm = XCreateBitmapFromData(win->display,
|
||||
win->basewin, xchess_bits,
|
||||
xchess_width, xchess_height);
|
||||
|
@ -848,7 +848,7 @@ setup(dispname, win)
|
|||
xchess_x_hot, xchess_y_hot);
|
||||
XFreePixmap(win->display, bm);
|
||||
XFreePixmap(win->display, bmask);
|
||||
|
||||
|
||||
XDefineCursor(win->display,win->basewin, cur);
|
||||
|
||||
XMapSubwindows(win->display,win->basewin);
|
||||
|
@ -866,7 +866,7 @@ setup(dispname, win)
|
|||
ButtonReleaseMask | ExposureMask);
|
||||
XSelectInput(win->display,win->buttonwin,
|
||||
ButtonPressMask | ExposureMask);
|
||||
|
||||
|
||||
message_init(win);
|
||||
record_init(win);
|
||||
button_draw(win);
|
||||
|
@ -900,12 +900,12 @@ drawgrid(win)
|
|||
gc.foreground = win->border.pixel;
|
||||
gc.line_width = 0;
|
||||
gc.line_style = LineSolid;
|
||||
|
||||
|
||||
XChangeGC(win->display,
|
||||
DefaultGC(win->display, 0),
|
||||
GCFunction | GCPlaneMask | GCForeground |
|
||||
GCLineWidth | GCLineStyle, &gc);
|
||||
|
||||
|
||||
/* Draw the lines... horizontal, */
|
||||
for (i = 1; i < SIZE; i++)
|
||||
XDrawLine(win->display, win->boardwin,
|
||||
|
@ -923,7 +923,7 @@ drawgrid(win)
|
|||
i * (SQUARE_WIDTH + BORDER_WIDTH) -
|
||||
BORDER_WIDTH / 2, 0,
|
||||
i * (SQUARE_WIDTH + BORDER_WIDTH) -
|
||||
BORDER_WIDTH / 2,
|
||||
BORDER_WIDTH / 2,
|
||||
SIZE * (SQUARE_WIDTH + BORDER_WIDTH));
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -20,8 +20,8 @@ file named COPYING. Among other things, the copyright notice
|
|||
and this notice must be preserved on all copies. */
|
||||
|
||||
|
||||
/* RCS Info: $Revision: 1.2 $ on $Date: 89/04/28 08:44:02 $
|
||||
* $Source: /usr/local/src/source/X.V11R3/contrib/games/xchess/Xchess/RCS/xchess.c,v $
|
||||
/* RCS Info: $Revision: 1.1.1.1 $ on $Date: 1993/06/12 14:41:09 $
|
||||
* $Source: /home/ncvs/src/gnu/games/chess/Xchess/xchess.c,v $
|
||||
* Copyright (c) 1986 Wayne A. Christopher, U. C. Berkeley CAD Group
|
||||
* Permission is granted to do anything with this code except sell it
|
||||
* or remove this message.
|
||||
|
@ -82,7 +82,7 @@ main(ac, av)
|
|||
char *s;
|
||||
|
||||
program = av[0];
|
||||
|
||||
|
||||
#ifdef notdef
|
||||
signal(SIGCHLD, die);
|
||||
#endif
|
||||
|
@ -157,7 +157,7 @@ main(ac, av)
|
|||
|
||||
if (!dispname2)
|
||||
oneboard = true;
|
||||
|
||||
|
||||
srandom(getpid());
|
||||
|
||||
if (!oneboard && randflag && (random() % 2)) {
|
||||
|
@ -165,10 +165,10 @@ main(ac, av)
|
|||
dispname1 = dispname2;
|
||||
dispname2 = s;
|
||||
}
|
||||
|
||||
|
||||
if (!dispname1)
|
||||
dispname1 = getenv("DISPLAY");
|
||||
|
||||
|
||||
/* Set up the board. */
|
||||
board_setup();
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
C source for CHESS
|
||||
C source for CHESS
|
||||
|
||||
Revision: 4-25-88
|
||||
|
||||
|
@ -44,7 +44,7 @@
|
|||
|
||||
#define neutral 2
|
||||
#define white 0
|
||||
#define black 1
|
||||
#define black 1
|
||||
#define no_piece 0
|
||||
#define pawn 1
|
||||
#define knight 2
|
||||
|
@ -164,7 +164,7 @@ short unmap[120]=
|
|||
40,41,42,43,44,45,46,47,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
48,49,50,51,52,53,54,55,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
56,57,58,59,60,61,62,63};
|
||||
short Dcode[120]=
|
||||
short Dcode[120]=
|
||||
{0,1,1,1,1,1,1,1,0,0,0,0,0,0,0x0E,0x0F,
|
||||
0x10,0x11,0x12,0,0,0,0,0,0,0,0,0,0,0,0x0F,0x1F,
|
||||
0x10,0x21,0x11,0,0,0,0,0,0,0,0,0,0,0x0F,0,0,
|
||||
|
@ -287,7 +287,7 @@ short PawnAdvance[64]=
|
|||
12,16,24,32,32,24,16,12,
|
||||
12,16,24,32,32,24,16,12,
|
||||
0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
|
||||
|
||||
main(argc,argv)
|
||||
int argc; char *argv[];
|
||||
|
@ -331,8 +331,8 @@ short iop;
|
|||
unsigned short *mv;
|
||||
|
||||
/*
|
||||
Compare the string 's' to the list of legal moves available for the
|
||||
opponent. If a match is found, make the move on the board.
|
||||
Compare the string 's' to the list of legal moves available for the
|
||||
opponent. If a match is found, make the move on the board.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -373,7 +373,7 @@ struct leaf *node;
|
|||
if (xnode.flags & epmask) UpdateDisplay(0,0,1,0);
|
||||
else UpdateDisplay(xnode.f,xnode.t,0,xnode.flags & cstlmask);
|
||||
if (xnode.flags & cstlmask) Game50 = GameCnt;
|
||||
else if (board[xnode.t] == pawn || (xnode.flags & capture))
|
||||
else if (board[xnode.t] == pawn || (xnode.flags & capture))
|
||||
Game50 = GameCnt;
|
||||
GameList[GameCnt].depth = GameList[GameCnt].score = 0;
|
||||
GameList[GameCnt].nodes = 0;
|
||||
|
@ -384,7 +384,7 @@ struct leaf *node;
|
|||
*mv = (xnode.f << 8) + xnode.t;
|
||||
algbr(xnode.f,xnode.t,false);
|
||||
return(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (cnt > 1) ShowMessage("Ambiguous Move!");
|
||||
return(false);
|
||||
|
@ -464,12 +464,12 @@ SelectMove(side,iop)
|
|||
short side,iop;
|
||||
|
||||
/*
|
||||
Select a move by calling function search() at progressively deeper
|
||||
ply until time is up or a mate or draw is reached. An alpha-beta
|
||||
window of -90 to +90 points is set around the score returned from the
|
||||
previous iteration. If Sdepth != 0 then the program has correctly
|
||||
predicted the opponents move and the search will start at a depth of
|
||||
Sdepth+1 rather than a depth of 1.
|
||||
Select a move by calling function search() at progressively deeper
|
||||
ply until time is up or a mate or draw is reached. An alpha-beta
|
||||
window of -90 to +90 points is set around the score returned from the
|
||||
previous iteration. If Sdepth != 0 then the program has correctly
|
||||
predicted the opponents move and the search will start at a depth of
|
||||
Sdepth+1 rather than a depth of 1.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -495,7 +495,7 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
ExaminePosition();
|
||||
ScorePosition(side,&score);
|
||||
ShowSidetomove();
|
||||
|
||||
|
||||
if (Sdepth == 0)
|
||||
{
|
||||
ZeroTTable();
|
||||
|
@ -516,7 +516,7 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
NodeCnt = ETnodes = EvalNodes = HashCnt = 0;
|
||||
Zscore = 0; zwndw = 20;
|
||||
}
|
||||
|
||||
|
||||
while (!timeout && Sdepth < MaxSearchDepth)
|
||||
{
|
||||
Sdepth++;
|
||||
|
@ -576,7 +576,7 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
if (score == -9999 || score == 9998) mate = true;
|
||||
if (mate) hint = 0;
|
||||
if (root->flags & cstlmask) Game50 = GameCnt;
|
||||
else if (board[root->t] == pawn || (root->flags & capture))
|
||||
else if (board[root->t] == pawn || (root->flags & capture))
|
||||
Game50 = GameCnt;
|
||||
GameList[GameCnt].score = score;
|
||||
GameList[GameCnt].nodes = NodeCnt;
|
||||
|
@ -599,13 +599,13 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
OpeningBook()
|
||||
|
||||
/*
|
||||
Go thru each of the opening lines of play and check for a match with
|
||||
the current game listing. If a match occurs, generate a random number.
|
||||
If this number is the largest generated so far then the next move in
|
||||
this line becomes the current "candidate". After all lines are
|
||||
checked, the candidate move is put at the top of the Tree[] array and
|
||||
will be played by the program. Note that the program does not handle
|
||||
book transpositions.
|
||||
Go thru each of the opening lines of play and check for a match with
|
||||
the current game listing. If a match occurs, generate a random number.
|
||||
If this number is the largest generated so far then the next move in
|
||||
this line becomes the current "candidate". After all lines are
|
||||
checked, the candidate move is put at the top of the Tree[] array and
|
||||
will be played by the program. Note that the program does not handle
|
||||
book transpositions.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -630,7 +630,7 @@ struct BookEntry *p;
|
|||
}
|
||||
p = p->next;
|
||||
}
|
||||
|
||||
|
||||
for (pnt = TrPnt[1]; pnt < TrPnt[2]; pnt++)
|
||||
if ((Tree[pnt].f<<8) + Tree[pnt].t == m) Tree[pnt].score = 0;
|
||||
pick(TrPnt[1],TrPnt[2]-1);
|
||||
|
@ -658,12 +658,12 @@ short side,ply,depth,alpha,beta,*rpt;
|
|||
unsigned short bstline[];
|
||||
|
||||
/*
|
||||
Perform an alpha-beta search to determine the score for the current
|
||||
board position. If depth <= 0 only capturing moves, pawn promotions
|
||||
and responses to check are generated and searched, otherwise all
|
||||
moves are processed. The search depth is modified for check evasions,
|
||||
certain re-captures and threats. Extensions may continue for up to 11
|
||||
ply beyond the nominal search depth.
|
||||
Perform an alpha-beta search to determine the score for the current
|
||||
board position. If depth <= 0 only capturing moves, pawn promotions
|
||||
and responses to check are generated and searched, otherwise all
|
||||
moves are processed. The search depth is modified for check evasions,
|
||||
certain re-captures and threats. Extensions may continue for up to 11
|
||||
ply beyond the nominal search depth.
|
||||
*/
|
||||
|
||||
#define prune (cf && score+node->score < alpha)
|
||||
|
@ -683,7 +683,7 @@ struct leaf *node,tmp;
|
|||
NodeCnt++;
|
||||
xside = otherside[side];
|
||||
if (depth < 0) depth = 0;
|
||||
|
||||
|
||||
if (ply <= Sdepth+3) repetition(rpt); else *rpt = 0;
|
||||
if (*rpt >= 2) return(0);
|
||||
|
||||
|
@ -693,7 +693,7 @@ struct leaf *node,tmp;
|
|||
bstline[ply] = 0;
|
||||
return(score);
|
||||
}
|
||||
|
||||
|
||||
if (depth > 0)
|
||||
{
|
||||
if (InChk || PawnThreat[ply-1] || ReCapture) ++depth;
|
||||
|
@ -704,7 +704,7 @@ struct leaf *node,tmp;
|
|||
(InChk || PawnThreat[ply-1] || Threat[ply-1])) ++depth;
|
||||
else if (score <= beta && MateThreat) ++depth;
|
||||
}
|
||||
|
||||
|
||||
if (depth > 0 && hashflag && ply > 1)
|
||||
{
|
||||
ProbeTTable(side,depth,&alpha,&beta,&score);
|
||||
|
@ -713,21 +713,21 @@ struct leaf *node,tmp;
|
|||
if (beta == -20000) return(score);
|
||||
if (alpha > beta) return(alpha);
|
||||
}
|
||||
|
||||
|
||||
if (Sdepth == 1) d = 7; else d = 11;
|
||||
if (ply > Sdepth+d || (depth < 1 && score > beta)) return(score);
|
||||
|
||||
if (ply > 1)
|
||||
if (depth > 0) MoveList(side,ply);
|
||||
else CaptureList(side,xside,ply);
|
||||
|
||||
|
||||
if (TrPnt[ply] == TrPnt[ply+1]) return(score);
|
||||
|
||||
|
||||
cf = (depth < 1 && ply > Sdepth+1 && !ChkFlag[ply-2] && !slk);
|
||||
|
||||
if (depth > 0) best = -12000; else best = score;
|
||||
if (best > alpha) alpha = best;
|
||||
|
||||
|
||||
for (pnt = pbst = TrPnt[ply];
|
||||
pnt < TrPnt[ply+1] && best <= beta;
|
||||
pnt++)
|
||||
|
@ -736,7 +736,7 @@ struct leaf *node,tmp;
|
|||
node = &Tree[pnt];
|
||||
mv = (node->f << 8) + node->t;
|
||||
nxtline[ply+1] = 0;
|
||||
|
||||
|
||||
if (prune) break;
|
||||
if (ply == 1) UpdateSearchStatus;
|
||||
|
||||
|
@ -789,7 +789,7 @@ struct leaf *node,tmp;
|
|||
if (NodeCnt > ETnodes) ElapsedTime(0);
|
||||
if (timeout) return(-Tscore[ply-1]);
|
||||
}
|
||||
|
||||
|
||||
node = &Tree[pbst];
|
||||
mv = (node->f<<8) + node->t;
|
||||
if (hashflag && ply <= Sdepth && *rpt == 0 && best == alpha)
|
||||
|
@ -815,13 +815,13 @@ evaluate(side,xside,ply,alpha,beta)
|
|||
short side,xside,ply,alpha,beta;
|
||||
|
||||
/*
|
||||
Compute an estimate of the score by adding the positional score from
|
||||
the previous ply to the material difference. If this score falls
|
||||
inside a window which is 180 points wider than the alpha-beta window
|
||||
(or within a 50 point window during quiescence search) call
|
||||
ScorePosition() to determine a score, otherwise return the estimated
|
||||
score. If one side has only a king and the other either has no pawns
|
||||
or no pieces then the function ScoreLoneKing() is called.
|
||||
Compute an estimate of the score by adding the positional score from
|
||||
the previous ply to the material difference. If this score falls
|
||||
inside a window which is 180 points wider than the alpha-beta window
|
||||
(or within a 50 point window during quiescence search) call
|
||||
ScorePosition() to determine a score, otherwise return the estimated
|
||||
score. If one side has only a king and the other either has no pawns
|
||||
or no pieces then the function ScoreLoneKing() is called.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -832,14 +832,14 @@ short s,evflag;
|
|||
(mtl[black] == valueK && (pmtl[white] == 0 || emtl[white] == 0)));
|
||||
s = -Pscore[ply-1] + mtl[side] - mtl[xside];
|
||||
s -= INCscore;
|
||||
|
||||
|
||||
if (slk) evflag = false;
|
||||
else evflag =
|
||||
else evflag =
|
||||
(ply == 1 || ply < Sdepth ||
|
||||
((ply == Sdepth+1 || ply == Sdepth+2) &&
|
||||
(s > alpha-xwndw && s < beta+xwndw)) ||
|
||||
(ply > Sdepth+2 && s >= alpha-25 && s <= beta+25));
|
||||
|
||||
|
||||
if (evflag)
|
||||
{
|
||||
EvalNodes++;
|
||||
|
@ -855,7 +855,7 @@ short s,evflag;
|
|||
InChk = SqAtakd(PieceList[side][0],xside);
|
||||
if (slk) ScoreLoneKing(side,&s);
|
||||
}
|
||||
|
||||
|
||||
Pscore[ply] = s - mtl[side] + mtl[xside];
|
||||
if (InChk) ChkFlag[ply-1] = Pindex[TOsquare];
|
||||
else ChkFlag[ply-1] = 0;
|
||||
|
@ -867,7 +867,7 @@ short s,evflag;
|
|||
ProbeTTable(side,depth,alpha,beta,score)
|
||||
short side,depth,*alpha,*beta,*score;
|
||||
|
||||
/*
|
||||
/*
|
||||
Look for the current board position in the transposition table.
|
||||
*/
|
||||
|
||||
|
@ -916,7 +916,7 @@ short hindx;
|
|||
ptbl = (ttable + hindx);
|
||||
ptbl->hashbd = hashbd;
|
||||
ptbl->depth = depth;
|
||||
ptbl->score = score;
|
||||
ptbl->score = score;
|
||||
ptbl->mv = mv;
|
||||
ptbl->flags = 0;
|
||||
if (score < alpha) ptbl->flags |= upperbound;
|
||||
|
@ -941,10 +941,10 @@ MoveList(side,ply)
|
|||
short side,ply;
|
||||
|
||||
/*
|
||||
Fill the array Tree[] with all available moves for side to play. Array
|
||||
TrPnt[ply] contains the index into Tree[] of the first move at a ply.
|
||||
Fill the array Tree[] with all available moves for side to play. Array
|
||||
TrPnt[ply] contains the index into Tree[] of the first move at a ply.
|
||||
*/
|
||||
|
||||
|
||||
{
|
||||
register short i;
|
||||
short xside,f;
|
||||
|
@ -979,16 +979,16 @@ GenMoves(ply,sq,side,xside)
|
|||
short ply,sq,side,xside;
|
||||
|
||||
/*
|
||||
Generate moves for a piece. The from square is mapped onto a special
|
||||
board and offsets (taken from array Dir[]) are added to the mapped
|
||||
location. The newly generated square is tested to see if it falls off
|
||||
the board by ANDing the square with 88 HEX. Legal moves are linked
|
||||
into the tree.
|
||||
Generate moves for a piece. The from square is mapped onto a special
|
||||
board and offsets (taken from array Dir[]) are added to the mapped
|
||||
location. The newly generated square is tested to see if it falls off
|
||||
the board by ANDing the square with 88 HEX. Legal moves are linked
|
||||
into the tree.
|
||||
*/
|
||||
|
||||
|
||||
{
|
||||
register short m,u,d;
|
||||
short i,m0,piece;
|
||||
short i,m0,piece;
|
||||
|
||||
piece = board[sq]; m0 = map[sq];
|
||||
if (sweep[piece])
|
||||
|
@ -1057,7 +1057,7 @@ short ply,f,t,xside;
|
|||
2. Capture of last moved piece
|
||||
3. Other captures (major pieces first)
|
||||
4. Killer moves
|
||||
5. "history" killers
|
||||
5. "history" killers
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -1140,7 +1140,7 @@ struct leaf *node;
|
|||
}
|
||||
PL = PieceList[side];
|
||||
for (i = 0; i <= PieceCnt[side]; i++)
|
||||
{
|
||||
{
|
||||
sq = PL[i];
|
||||
m0 = map[sq]; piece = board[sq];
|
||||
j1 = Dstart[piece]; j2 = Dstop[piece];
|
||||
|
@ -1176,7 +1176,7 @@ struct leaf *node;
|
|||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
int castle(side,kf,kt,iop)
|
||||
short side,kf,kt,iop;
|
||||
|
||||
|
@ -1244,7 +1244,7 @@ short l;
|
|||
{
|
||||
board[l] = no_piece; color[l] = neutral;
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
board[l] = pawn; color[l] = xside;
|
||||
}
|
||||
|
@ -1257,11 +1257,11 @@ short side,*tempc,*tempb,*tempsf,*tempst;
|
|||
struct leaf *node;
|
||||
|
||||
/*
|
||||
Update Arrays board[], color[], and Pindex[] to reflect the new board
|
||||
position obtained after making the move pointed to by node. Also
|
||||
update miscellaneous stuff that changes when a move is made.
|
||||
Update Arrays board[], color[], and Pindex[] to reflect the new board
|
||||
position obtained after making the move pointed to by node. Also
|
||||
update miscellaneous stuff that changes when a move is made.
|
||||
*/
|
||||
|
||||
|
||||
{
|
||||
register short f,t;
|
||||
short xside,ct,cf;
|
||||
|
@ -1323,7 +1323,7 @@ short xside,ct,cf;
|
|||
UpdateHashbd(side,queen,f,-1);
|
||||
}
|
||||
INCscore -= *tempsf;
|
||||
}
|
||||
}
|
||||
if (board[t] == king) ++kingmoved[side];
|
||||
if (node->flags & epmask) EnPassant(xside,f,t,1);
|
||||
else if (hashflag) UpdateHashbd(side,board[t],f,t);
|
||||
|
@ -1363,7 +1363,7 @@ short xside;
|
|||
UpdateHashbd(side,queen,-1,t);
|
||||
UpdateHashbd(side,pawn,-1,t);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (*tempc != neutral)
|
||||
{
|
||||
UpdatePieceList(*tempc,t,2);
|
||||
|
@ -1388,10 +1388,10 @@ UpdateHashbd(side,piece,f,t)
|
|||
short side,piece,f,t;
|
||||
|
||||
/*
|
||||
hashbd contains a 32 bit "signature" of the board position. hashkey
|
||||
contains a 16 bit code used to address the hash table. When a move is
|
||||
made, XOR'ing the hashcode of moved piece on the from and to squares
|
||||
with the hashbd and hashkey values keeps things current.
|
||||
hashbd contains a 32 bit "signature" of the board position. hashkey
|
||||
contains a 16 bit code used to address the hash table. When a move is
|
||||
made, XOR'ing the hashcode of moved piece on the from and to squares
|
||||
with the hashbd and hashkey values keeps things current.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -1412,8 +1412,8 @@ UpdatePieceList(side,sq,iop)
|
|||
short side,sq,iop;
|
||||
|
||||
/*
|
||||
Update the PieceList and Pindex arrays when a piece is captured or
|
||||
when a capture is unmade.
|
||||
Update the PieceList and Pindex arrays when a piece is captured or
|
||||
when a capture is unmade.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -1439,13 +1439,13 @@ register short i;
|
|||
InitializeStats()
|
||||
|
||||
/*
|
||||
Scan thru the board seeing what's on each square. If a piece is found,
|
||||
update the variables PieceCnt, PawnCnt, Pindex and PieceList. Also
|
||||
determine the material for each side and set the hashkey and hashbd
|
||||
variables to represent the current board position. Array
|
||||
PieceList[side][indx] contains the location of all the pieces of
|
||||
either side. Array Pindex[sq] contains the indx into PieceList for a
|
||||
given square.
|
||||
Scan thru the board seeing what's on each square. If a piece is found,
|
||||
update the variables PieceCnt, PawnCnt, Pindex and PieceList. Also
|
||||
determine the material for each side and set the hashkey and hashbd
|
||||
variables to represent the current board position. Array
|
||||
PieceList[side][indx] contains the location of all the pieces of
|
||||
either side. Array Pindex[sq] contains the indx into PieceList for a
|
||||
given square.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -1477,9 +1477,9 @@ register short i,sq;
|
|||
pick(p1,p2)
|
||||
short p1,p2;
|
||||
|
||||
/*
|
||||
Find the best move in the tree between indexes p1 and p2. Swap the
|
||||
best move into the p1 element.
|
||||
/*
|
||||
Find the best move in the tree between indexes p1 and p2. Swap the
|
||||
best move into the p1 element.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -1535,7 +1535,7 @@ short sq,side;
|
|||
/*
|
||||
See if any piece with color 'side' ataks sq. First check for pawns
|
||||
or king, then try other pieces. Array Dcode is used to check for
|
||||
knight attacks or R,B,Q co-linearity.
|
||||
knight attacks or R,B,Q co-linearity.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -1550,7 +1550,7 @@ short i,m0,m1,loc,piece,*PL;
|
|||
if (!(m & 0x88))
|
||||
if (board[unmap[m]] == pawn && color[unmap[m]] == side) return(true);
|
||||
if (distance(sq,PieceList[side][0]) == 1) return(true);
|
||||
|
||||
|
||||
PL = PieceList[side];
|
||||
for (i = 1; i <= PieceCnt[side]; i++)
|
||||
{
|
||||
|
@ -1584,7 +1584,7 @@ short side,*a;
|
|||
{
|
||||
register short u,m;
|
||||
short d,c,j,j1,j2,piece,i,m0,sq,*PL;
|
||||
|
||||
|
||||
/*
|
||||
memset((char *)a,0,64*sizeof(short));
|
||||
*/
|
||||
|
@ -1626,9 +1626,9 @@ ScorePosition(side,score)
|
|||
short side,*score;
|
||||
|
||||
/*
|
||||
Perform normal static evaluation of board position. A score is
|
||||
generated for each piece and these are summed to get a score for each
|
||||
side.
|
||||
Perform normal static evaluation of board position. A score is
|
||||
generated for each piece and these are summed to get a score for each
|
||||
side.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -1656,17 +1656,17 @@ short i,xside,pscore[3];
|
|||
}
|
||||
if (hung[side] > 1) pscore[side] += HUNGX;
|
||||
if (hung[xside] > 1) pscore[xside] += HUNGX;
|
||||
|
||||
|
||||
*score = mtl[side] - mtl[xside] + pscore[side] - pscore[xside] + 10;
|
||||
if (dither) *score += rand() % dither;
|
||||
|
||||
|
||||
if (*score > 0 && pmtl[side] == 0)
|
||||
if (emtl[side] < valueR) *score = 0;
|
||||
else if (*score < valueR) *score /= 2;
|
||||
if (*score < 0 && pmtl[xside] == 0)
|
||||
if (emtl[xside] < valueR) *score = 0;
|
||||
else if (-*score < valueR) *score /= 2;
|
||||
|
||||
|
||||
if (mtl[xside] == valueK && emtl[side] > valueB) *score += 200;
|
||||
if (mtl[side] == valueK && emtl[xside] > valueB) *score -= 200;
|
||||
}
|
||||
|
@ -1675,7 +1675,7 @@ short i,xside,pscore[3];
|
|||
ScoreLoneKing(side,score)
|
||||
short side,*score;
|
||||
|
||||
/*
|
||||
/*
|
||||
Static evaluation when loser has only a king and winner has no pawns
|
||||
or no pieces.
|
||||
*/
|
||||
|
@ -1687,19 +1687,19 @@ short winner,loser,king1,king2,s,i;
|
|||
if (mtl[white] > mtl[black]) winner = white; else winner = black;
|
||||
loser = otherside[winner];
|
||||
king1 = PieceList[winner][0]; king2 = PieceList[loser][0];
|
||||
|
||||
|
||||
s = 0;
|
||||
|
||||
|
||||
if (pmtl[winner] > 0)
|
||||
for (i = 1; i <= PieceCnt[winner]; i++)
|
||||
s += ScoreKPK(side,winner,loser,king1,king2,PieceList[winner][i]);
|
||||
|
||||
|
||||
else if (emtl[winner] == valueB+valueN)
|
||||
s = ScoreKBNK(winner,king1,king2);
|
||||
|
||||
|
||||
else if (emtl[winner] > valueB)
|
||||
s = 500 + emtl[winner] - DyingKing[king2] - 2*distance(king1,king2);
|
||||
|
||||
|
||||
if (side == winner) *score = s; else *score = -s;
|
||||
}
|
||||
|
||||
|
@ -1713,7 +1713,7 @@ short side,winner,loser,king1,king2,sq;
|
|||
|
||||
{
|
||||
short s,r;
|
||||
|
||||
|
||||
if (PieceCnt[winner] == 1) s = 50; else s = 120;
|
||||
if (winner == white)
|
||||
{
|
||||
|
@ -1883,8 +1883,8 @@ short s,piece,a1,a2,in_square,r,mob,e,c;
|
|||
if (PC2[7] == 0) s += KHOPNX;
|
||||
}
|
||||
}
|
||||
|
||||
if (a2 > 0)
|
||||
|
||||
if (a2 > 0)
|
||||
{
|
||||
c = (control[piece] & 0x4FFF);
|
||||
if (a1 == 0 || a2 > c+1)
|
||||
|
@ -1977,8 +1977,8 @@ BRscan(sq,s,mob)
|
|||
short sq,*s,*mob;
|
||||
|
||||
/*
|
||||
Find Bishop and Rook mobility, XRAY attacks, and pins. Increment the
|
||||
hung[] array if a pin is found.
|
||||
Find Bishop and Rook mobility, XRAY attacks, and pins. Increment the
|
||||
hung[] array if a pin is found.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -2077,9 +2077,9 @@ short i,m0;
|
|||
ExaminePosition()
|
||||
|
||||
/*
|
||||
This is done one time before the search is started. Set up arrays
|
||||
Mwpawn, Mbpawn, Mknight, Mbishop, Mking which are used in the
|
||||
SqValue() function to determine the positional value of each piece.
|
||||
This is done one time before the search is started. Set up arrays
|
||||
Mwpawn, Mbpawn, Mknight, Mbishop, Mking which are used in the
|
||||
SqValue() function to determine the positional value of each piece.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -2114,14 +2114,14 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
if (!PawnStorm && stage < 5)
|
||||
PawnStorm = ((column[wking] < 3 && column[bking] > 4) ||
|
||||
(column[wking] > 4 && column[bking] < 3));
|
||||
|
||||
|
||||
CopyBoard(pknight,Mknight[white]);
|
||||
CopyBoard(pknight,Mknight[black]);
|
||||
CopyBoard(pbishop,Mbishop[white]);
|
||||
CopyBoard(pbishop,Mbishop[black]);
|
||||
BlendBoard(KingOpening,KingEnding,Mking[white]);
|
||||
BlendBoard(KingOpening,KingEnding,Mking[black]);
|
||||
|
||||
|
||||
for (sq = 0; sq < 64; sq++)
|
||||
{
|
||||
fyle = column[sq]; rank = row[sq];
|
||||
|
@ -2159,7 +2159,7 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
if ((column[bking] < 4 && fyle > 4) ||
|
||||
(column[bking] > 3 && fyle < 3)) Mbpawn[sq] -= 3*rank;
|
||||
}
|
||||
|
||||
|
||||
Mknight[white][sq] += 5 - distance(sq,bking);
|
||||
Mknight[white][sq] += 5 - distance(sq,wking);
|
||||
Mknight[black][sq] += 5 - distance(sq,wking);
|
||||
|
@ -2176,19 +2176,19 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
if (bstrong) Mknight[black][sq] += KNIGHTSTRONG;
|
||||
if (wstrong) Mbishop[white][sq] += BISHOPSTRONG;
|
||||
if (bstrong) Mbishop[black][sq] += BISHOPSTRONG;
|
||||
|
||||
|
||||
if (HasBishop[white] == 2) Mbishop[white][sq] += 8;
|
||||
if (HasBishop[black] == 2) Mbishop[black][sq] += 8;
|
||||
if (HasKnight[white] == 2) Mknight[white][sq] += 5;
|
||||
if (HasKnight[black] == 2) Mknight[black][sq] += 5;
|
||||
|
||||
|
||||
if (board[sq] == bishop)
|
||||
if (rank % 2 == fyle % 2) KBNKsq = 0; else KBNKsq = 7;
|
||||
|
||||
|
||||
Kfield[white][sq] = Kfield[black][sq] = 0;
|
||||
if (distance(sq,wking) == 1) Kfield[black][sq] = KATAK;
|
||||
if (distance(sq,bking) == 1) Kfield[white][sq] = KATAK;
|
||||
|
||||
|
||||
Pd = 0;
|
||||
for (i = 0; i < 64; i++)
|
||||
if (board[i] == pawn)
|
||||
|
@ -2221,9 +2221,9 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
|
||||
UpdateWeights()
|
||||
|
||||
/*
|
||||
If material balance has changed, determine the values for the
|
||||
positional evaluation terms.
|
||||
/*
|
||||
If material balance has changed, determine the values for the
|
||||
positional evaluation terms.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -2241,7 +2241,7 @@ short tmtl;
|
|||
if (tmtl > 3600) stage2 = 0;
|
||||
else if (tmtl < 1400) stage2 = 10;
|
||||
else stage2 = (3600-tmtl) / 220;
|
||||
|
||||
|
||||
PEDRNK2B = -15; /* centre pawn on 2nd rank & blocked */
|
||||
PBLOK = -4; /* blocked backward pawn */
|
||||
PDOUBLED = -14; /* doubled pawn */
|
||||
|
@ -2250,27 +2250,27 @@ short tmtl;
|
|||
PADVNCM = 10; /* advanced pawn multiplier */
|
||||
PADVNCI = 7; /* muliplier for isolated pawn */
|
||||
PawnBonus = stage;
|
||||
|
||||
|
||||
KNIGHTPOST = (stage+2)/3; /* knight near enemy pieces */
|
||||
KNIGHTSTRONG = (stage+6)/2; /* occupies pawn hole */
|
||||
|
||||
|
||||
BISHOPSTRONG = (stage+6)/2; /* occupies pawn hole */
|
||||
BishopBonus = 2*stage;
|
||||
|
||||
|
||||
RHOPN = 10; /* rook on half open file */
|
||||
RHOPNX = 4;
|
||||
RookBonus = 6*stage;
|
||||
|
||||
|
||||
XRAY = 8; /* Xray attack on piece */
|
||||
PINVAL = 10; /* Pin */
|
||||
|
||||
|
||||
KHOPN = (3*stage-30) / 2; /* king on half open file */
|
||||
KHOPNX = KHOPN / 2;
|
||||
KCASTLD = 10 - stage;
|
||||
KMOVD = -40 / (stage+1); /* king moved before castling */
|
||||
KATAK = (10-stage) / 2; /* B,R attacks near enemy king */
|
||||
if (stage < 8) KSFTY = 16-2*stage; else KSFTY = 0;
|
||||
|
||||
|
||||
ATAKD = -6; /* defender > attacker */
|
||||
HUNGP = -8; /* each hung piece */
|
||||
HUNGX = -12; /* extra for >1 hung piece */
|
||||
|
|
|
@ -21,11 +21,11 @@
|
|||
*/
|
||||
|
||||
|
||||
/* Header file for GNU CHESS */
|
||||
/* Header file for GNU CHESS */
|
||||
|
||||
#define neutral 2
|
||||
#define white 0
|
||||
#define black 1
|
||||
#define black 1
|
||||
#define no_piece 0
|
||||
#define pawn 1
|
||||
#define knight 2
|
||||
|
|
|
@ -161,7 +161,7 @@ short sq,side;
|
|||
u = p[u].nextpos;
|
||||
}
|
||||
else {
|
||||
if (color[u] == side &&
|
||||
if (color[u] == side &&
|
||||
(board[u] == queen || board[u] == bishop))
|
||||
return(true);
|
||||
u = p[u].nextdir;
|
||||
|
@ -175,7 +175,7 @@ short sq,side;
|
|||
u = p[u].nextpos;
|
||||
}
|
||||
else {
|
||||
if (color[u] == side &&
|
||||
if (color[u] == side &&
|
||||
(board[u] == queen || board[u] == rook))
|
||||
return(true);
|
||||
u = p[u].nextdir;
|
||||
|
@ -201,8 +201,8 @@ short sq,side;
|
|||
BRscan(sq,s,mob)
|
||||
short sq,*s,*mob;
|
||||
/*
|
||||
Find Bishop and Rook mobility, XRAY attacks, and pins. Increment the
|
||||
hung[] array if a pin is found.
|
||||
Find Bishop and Rook mobility, XRAY attacks, and pins. Increment the
|
||||
hung[] array if a pin is found.
|
||||
*/
|
||||
{
|
||||
register short u,piece,pin;
|
||||
|
@ -260,7 +260,7 @@ short side,xside,ply;
|
|||
register struct sqdata *p;
|
||||
short i,piece,*PL;
|
||||
struct leaf *node;
|
||||
|
||||
|
||||
TrPnt[ply+1] = TrPnt[ply];
|
||||
node = &Tree[TrPnt[ply]];
|
||||
PL = PieceList[side];
|
||||
|
@ -312,17 +312,17 @@ short side,xside,ply;
|
|||
#if (NEWMOVE > 5)
|
||||
GenMoves(ply,sq,side,xside)
|
||||
short ply,sq,side,xside;
|
||||
|
||||
|
||||
/*
|
||||
Generate moves for a piece. The moves are taken from the
|
||||
precalulated array posdata. If the board is free, next move
|
||||
is choosen from nextpos else from nextdir.
|
||||
*/
|
||||
|
||||
|
||||
{
|
||||
register short u,piece;
|
||||
register struct sqdata *p;
|
||||
|
||||
|
||||
piece = board[sq];
|
||||
p = posdata[side][piece][sq];
|
||||
if (piece == pawn) {
|
||||
|
@ -339,7 +339,7 @@ GenMoves(ply,sq,side,xside)
|
|||
}
|
||||
u = p[u].nextpos;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
u = p[sq].nextpos;
|
||||
while (u != sq) {
|
||||
|
@ -352,6 +352,6 @@ GenMoves(ply,sq,side,xside)
|
|||
u = p[u].nextdir;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -11,7 +11,7 @@ extern short taxidata[64][64];
|
|||
|
||||
extern void Initialize_dist();
|
||||
#endif
|
||||
|
||||
|
||||
#if (NEWMOVE >= 2)
|
||||
struct sqdata {
|
||||
short nextpos;
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
/*
|
||||
UNIX & MSDOS NON-DISPLAY, AND CHESSTOOL interface for Chess
|
||||
|
||||
|
||||
Revision: 4-25-88
|
||||
|
||||
|
||||
Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
|
||||
Copyright (c) 1988 John Stanback
|
||||
|
||||
|
@ -90,12 +90,12 @@ TerminateSearch()
|
|||
InputCommand()
|
||||
|
||||
/*
|
||||
Process the users command. If easy mode is OFF (the computer is
|
||||
thinking on opponents time) and the program is out of book, then make
|
||||
the 'hint' move on the board and call SelectMove() to find a response.
|
||||
The user terminates the search by entering ^C (quit siqnal) before
|
||||
entering a command. If the opponent does not make the hint move, then
|
||||
set Sdepth to zero.
|
||||
Process the users command. If easy mode is OFF (the computer is
|
||||
thinking on opponents time) and the program is out of book, then make
|
||||
the 'hint' move on the board and call SelectMove() to find a response.
|
||||
The user terminates the search by entering ^C (quit siqnal) before
|
||||
entering a command. If the opponent does not make the hint move, then
|
||||
set Sdepth to zero.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -124,7 +124,7 @@ char s[80];
|
|||
ft = time((long *)0) - time0;
|
||||
epsquare = tmp;
|
||||
}
|
||||
|
||||
|
||||
#ifndef MSDOS
|
||||
#endif
|
||||
while (!(ok || quit))
|
||||
|
@ -139,7 +139,7 @@ char s[80];
|
|||
Sdepth = 0;
|
||||
ft = 0;
|
||||
}
|
||||
|
||||
|
||||
if (strcmp(s,"bd") == 0)
|
||||
{
|
||||
ClrScreen();
|
||||
|
@ -183,7 +183,7 @@ char s[80];
|
|||
Sdepth = 0;
|
||||
ok = true;
|
||||
}
|
||||
if (strcmp(s,"white") == 0)
|
||||
if (strcmp(s,"white") == 0)
|
||||
{
|
||||
computer = white; opponent = black;
|
||||
ok = true; force = false;
|
||||
|
@ -196,7 +196,7 @@ char s[80];
|
|||
Sdepth = 0;
|
||||
}
|
||||
if (strcmp(s,"undo") == 0 && GameCnt >= 0) Undo();
|
||||
if (strcmp(s,"remove") == 0 && GameCnt >= 1)
|
||||
if (strcmp(s,"remove") == 0 && GameCnt >= 1)
|
||||
{
|
||||
Undo(); Undo();
|
||||
}
|
||||
|
@ -221,7 +221,7 @@ char s[80];
|
|||
printz("cnt= %ld rate= %ld\n",cnt,rate);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ElapsedTime(1);
|
||||
if (force)
|
||||
{
|
||||
|
@ -272,7 +272,7 @@ help()
|
|||
printz("Easy mode: ");
|
||||
if (easy) printz("ON\n"); else printz("OFF\n");
|
||||
printz("Depth: %d\n",MaxSearchDepth);
|
||||
printz("Random: ");
|
||||
printz("Random: ");
|
||||
if (dither) printz("ON\n"); else printz("OFF\n");
|
||||
printz("Transposition table: ");
|
||||
if (hashflag) printz("ON\n"); else printz("OFF\n");
|
||||
|
@ -282,10 +282,10 @@ help()
|
|||
|
||||
EditBoard()
|
||||
|
||||
/*
|
||||
Set up a board position. Pieces are entered by typing the piece
|
||||
followed by the location. For example, Nf3 will place a knight on
|
||||
square f3.
|
||||
/*
|
||||
Set up a board position. Pieces are entered by typing the piece
|
||||
followed by the location. For example, Nf3 will place a knight on
|
||||
square f3.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -297,7 +297,7 @@ char s[80];
|
|||
printz(". exit to main\n");
|
||||
printz("# clear board\n");
|
||||
printz("enter piece & location: \n");
|
||||
|
||||
|
||||
a = white;
|
||||
do
|
||||
{
|
||||
|
@ -399,12 +399,12 @@ OutputMove()
|
|||
NodeCnt,EvalNodes,HashCnt,evrate);
|
||||
printz("CPU= %.2ld:%.2ld.%.2ld\n\n",
|
||||
cputimer/6000,(cputimer % 6000)/100,cputimer % 100);
|
||||
|
||||
|
||||
if (root->flags & epmask) UpdateDisplay(0,0,1,0);
|
||||
else UpdateDisplay(root->f,root->t,0,root->flags & cstlmask);
|
||||
printz("My move is: %s\n\n",mvstr1);
|
||||
if (beep) printz("%c",7);
|
||||
|
||||
|
||||
if (root->flags & draw) printz("Draw game!\n");
|
||||
else if (root->score == -9999) printz("opponent mates!\n");
|
||||
else if (root->score == 9998) printz("computer mates!\n");
|
||||
|
@ -417,10 +417,10 @@ OutputMove()
|
|||
ElapsedTime(iop)
|
||||
short iop;
|
||||
|
||||
/*
|
||||
Determine the time that has passed since the search was started. If
|
||||
the elapsed time exceeds the target (ResponseTime+ExtraTime) then set
|
||||
timeout to true which will terminate the search.
|
||||
/*
|
||||
Determine the time that has passed since the search was started. If
|
||||
the elapsed time exceeds the target (ResponseTime+ExtraTime) then set
|
||||
timeout to true which will terminate the search.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -508,12 +508,12 @@ short r,c,l;
|
|||
GetOpenings()
|
||||
|
||||
/*
|
||||
Read in the Opening Book file and parse the algebraic notation for a
|
||||
move into an unsigned integer format indicating the from and to
|
||||
square. Create a linked list of opening lines of play, with
|
||||
entry->next pointing to the next line and entry->move pointing to a
|
||||
chunk of memory containing the moves. More Opening lines of up to 256
|
||||
half moves may be added to gnuchess.book.
|
||||
Read in the Opening Book file and parse the algebraic notation for a
|
||||
move into an unsigned integer format indicating the from and to
|
||||
square. Create a linked list of opening lines of play, with
|
||||
entry->next pointing to the next line and entry->move pointing to a
|
||||
chunk of memory containing the moves. More Opening lines of up to 256
|
||||
half moves may be added to gnuchess.book.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -542,7 +542,7 @@ unsigned short mv,*mp,tmp[100];
|
|||
mp = (unsigned short *)malloc((i+1)*sizeof(unsigned short));
|
||||
entry->mv = mp;
|
||||
entry->next = Book;
|
||||
Book = entry;
|
||||
Book = entry;
|
||||
for (j = 1; j <= i; j++) *(mp++) = tmp[j];
|
||||
*mp = 0;
|
||||
i = 0; side = white;
|
||||
|
@ -640,7 +640,7 @@ short sq,i,c;
|
|||
|
||||
printz("Enter file name: ");
|
||||
scanz("%s",fname);
|
||||
|
||||
|
||||
if (fname[0] == '\0' || access(fname,W_OK) == -1) strcpy(fname,"chess.000");
|
||||
fd = fopen(fname,"w");
|
||||
fprintf(fd,"%d %d %d\n",computer+1,opponent+1,Game50);
|
||||
|
@ -687,7 +687,7 @@ short i,f,t;
|
|||
}
|
||||
fprintf(fd,"\n\n");
|
||||
fclose(fd);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Undo()
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
/*
|
||||
ALPHA interface for CHESS
|
||||
|
||||
|
||||
Revision: 4-25-88
|
||||
|
||||
|
||||
Copyright (C) 1986, 1987, 1988 Free Software Foundation, Inc.
|
||||
Copyright (c) 1988 John Stanback
|
||||
|
||||
|
@ -88,12 +88,12 @@ TerminateSearch()
|
|||
InputCommand()
|
||||
|
||||
/*
|
||||
Process the users command. If easy mode is OFF (the computer is
|
||||
thinking on opponents time) and the program is out of book, then make
|
||||
the 'hint' move on the board and call SelectMove() to find a response.
|
||||
The user terminates the search by entering ^C (quit siqnal) before
|
||||
entering a command. If the opponent does not make the hint move, then
|
||||
set Sdepth to zero.
|
||||
Process the users command. If easy mode is OFF (the computer is
|
||||
thinking on opponents time) and the program is out of book, then make
|
||||
the 'hint' move on the board and call SelectMove() to find a response.
|
||||
The user terminates the search by entering ^C (quit siqnal) before
|
||||
entering a command. If the opponent does not make the hint move, then
|
||||
set Sdepth to zero.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -123,7 +123,7 @@ char s[80];
|
|||
ft = time((time_t *)0) - time0;
|
||||
epsquare = tmp;
|
||||
}
|
||||
|
||||
|
||||
signal(SIGINT,Die); signal(SIGQUIT,Die);
|
||||
while (!(ok || quit))
|
||||
{
|
||||
|
@ -136,7 +136,7 @@ char s[80];
|
|||
Sdepth = 0;
|
||||
ft = 0;
|
||||
}
|
||||
|
||||
|
||||
if (strcmp(s,"bd") == 0)
|
||||
{
|
||||
ClrScreen();
|
||||
|
@ -179,7 +179,7 @@ char s[80];
|
|||
Sdepth = 0;
|
||||
ok = true;
|
||||
}
|
||||
if (strcmp(s,"white") == 0)
|
||||
if (strcmp(s,"white") == 0)
|
||||
{
|
||||
computer = white; opponent = black;
|
||||
ok = true; force = false;
|
||||
|
@ -191,7 +191,7 @@ char s[80];
|
|||
ok = true; force = false;
|
||||
Sdepth = 0;
|
||||
}
|
||||
if (strcmp(s,"remove") == 0 && GameCnt >= 1)
|
||||
if (strcmp(s,"remove") == 0 && GameCnt >= 1)
|
||||
{
|
||||
Undo(); Undo();
|
||||
}
|
||||
|
@ -220,7 +220,7 @@ char s[80];
|
|||
if (strcmp(s,"p") == 0) ShowPostnValues();
|
||||
if (strcmp(s,"debug") == 0) DoDebug();
|
||||
}
|
||||
|
||||
|
||||
ClearMessage();
|
||||
ElapsedTime(1);
|
||||
if (force)
|
||||
|
@ -234,10 +234,10 @@ char s[80];
|
|||
|
||||
EditBoard()
|
||||
|
||||
/*
|
||||
Set up a board position. Pieces are entered by typing the piece
|
||||
followed by the location. For example, Nf3 will place a knight on
|
||||
square f3.
|
||||
/*
|
||||
Set up a board position. Pieces are entered by typing the piece
|
||||
followed by the location. For example, Nf3 will place a knight on
|
||||
square f3.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -322,7 +322,7 @@ help()
|
|||
gotoXY(10,24); printz("Easy mode: ");
|
||||
if (easy) printz("ON"); else printz("OFF");
|
||||
gotoXY(40,21); printz("Depth: %d",MaxSearchDepth);
|
||||
gotoXY(40,22); printz("Random: ");
|
||||
gotoXY(40,22); printz("Random: ");
|
||||
if (dither) printz("ON"); else printz("OFF");
|
||||
gotoXY(40,23); printz("Transposition table: ");
|
||||
if (hashflag) printz("ON"); else printz("OFF");
|
||||
|
@ -390,7 +390,7 @@ OutputMove()
|
|||
gotoXY(50,17); printz("My move is: %s",mvstr1);
|
||||
if (beep) putchar(7);
|
||||
ClrEoln();
|
||||
|
||||
|
||||
gotoXY(50,24);
|
||||
if (root->flags & draw) printz("Draw game!");
|
||||
else if (root->score == -9999) printz("opponent mates!");
|
||||
|
@ -398,7 +398,7 @@ OutputMove()
|
|||
else if (root->score < -9000) printz("opponent will soon mate!");
|
||||
else if (root->score > 9000) printz("computer will soon mate!");
|
||||
ClrEoln();
|
||||
|
||||
|
||||
if (post)
|
||||
{
|
||||
gotoXY(50,22); printz("Nodes= %6ld",NodeCnt); ClrEoln();
|
||||
|
@ -409,10 +409,10 @@ OutputMove()
|
|||
|
||||
ElapsedTime(iop)
|
||||
|
||||
/*
|
||||
Determine the time that has passed since the search was started. If
|
||||
the elapsed time exceeds the target (ResponseTime+ExtraTime) then set
|
||||
timeout to true which will terminate the search.
|
||||
/*
|
||||
Determine the time that has passed since the search was started. If
|
||||
the elapsed time exceeds the target (ResponseTime+ExtraTime) then set
|
||||
timeout to true which will terminate the search.
|
||||
*/
|
||||
|
||||
short iop;
|
||||
|
@ -515,7 +515,7 @@ short r,c; char x;
|
|||
UpdateDisplay(f,t,flag,iscastle)
|
||||
short f,t,flag,iscastle;
|
||||
{
|
||||
short i,l,z;
|
||||
short i,l,z;
|
||||
if (flag)
|
||||
{
|
||||
gotoXY(56,2); printz("CHESS");
|
||||
|
@ -557,12 +557,12 @@ short i,l,z;
|
|||
GetOpenings()
|
||||
|
||||
/*
|
||||
Read in the Opening Book file and parse the algebraic notation for a
|
||||
move into an unsigned integer format indicating the from and to
|
||||
square. Create a linked list of opening lines of play, with
|
||||
entry->next pointing to the next line and entry->move pointing to a
|
||||
chunk of memory containing the moves. More Opening lines of up to 256
|
||||
half moves may be added to gnuchess.book.
|
||||
Read in the Opening Book file and parse the algebraic notation for a
|
||||
move into an unsigned integer format indicating the from and to
|
||||
square. Create a linked list of opening lines of play, with
|
||||
entry->next pointing to the next line and entry->move pointing to a
|
||||
chunk of memory containing the moves. More Opening lines of up to 256
|
||||
half moves may be added to gnuchess.book.
|
||||
*/
|
||||
|
||||
{
|
||||
|
@ -587,7 +587,7 @@ unsigned short mv,*mp,tmp[100];
|
|||
mp = (unsigned short *)malloc((i+1)*sizeof(unsigned short));
|
||||
entry->mv = mp;
|
||||
entry->next = Book;
|
||||
Book = entry;
|
||||
Book = entry;
|
||||
for (j = 1; j <= i; j++) *(mp++) = tmp[j];
|
||||
*mp = 0;
|
||||
i = 0; side = white;
|
||||
|
@ -690,7 +690,7 @@ short sq,i,c;
|
|||
|
||||
ShowMessage("File name: ");
|
||||
scanz("%s",fname);
|
||||
|
||||
|
||||
if (fname[0] == '\0' || access(fname,W_OK) == -1) strcpy(fname,"chess.000");
|
||||
fd = fopen(fname,"w");
|
||||
fprintf(fd,"%d %d %d\n",computer+1,opponent+1,Game50);
|
||||
|
@ -737,7 +737,7 @@ short i,f,t;
|
|||
}
|
||||
fprintf(fd,"\n\n");
|
||||
fclose(fd);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Undo()
|
||||
|
@ -851,7 +851,7 @@ SelectLevel()
|
|||
gotoXY(20,11); printz(" 8. 1 move in 15 minutes");
|
||||
gotoXY(20,12); printz(" 9. 1 move in 60 minutes");
|
||||
gotoXY(20,13); printz("10. 1 move in 600 minutes");
|
||||
|
||||
|
||||
OperatorTime = 0; TCmoves = 60; TCminutes = 5;
|
||||
|
||||
gotoXY(20,17); printz("Enter Level: ");
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
#warning "this file includes <values.h> which is obsoleted, use <limits.h> or <float.h> instead"
|
||||
#endif
|
||||
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -72,7 +72,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#define DMAXEXP ((1 << _DEXPLEN - 1) - 1 + _IEEE)
|
||||
#define FMAXEXP ((1 << _FEXPLEN - 1) - 1 + _IEEE)
|
||||
|
||||
#elif defined(sony)
|
||||
#elif defined(sony)
|
||||
#define MAXDOUBLE 1.79769313486231470e+308
|
||||
#define MAXFLOAT ((float)3.40282346638528860e+38)
|
||||
#define MINDOUBLE 2.2250738585072010e-308
|
||||
|
@ -150,7 +150,7 @@ extern float _maxfloat, _minfloat;
|
|||
|
||||
/* #elif defined(vax) */
|
||||
/* use vax versions by default -- they seem to be the most conservative */
|
||||
#else
|
||||
#else
|
||||
|
||||
#define MAXDOUBLE 1.701411834604692293e+38
|
||||
#define MINDOUBLE (2.938735877055718770e-39)
|
||||
|
|
|
@ -79,7 +79,7 @@ int dialog_checklist(unsigned char *title, unsigned char *prompt, int height, in
|
|||
/* center dialog box on screen */
|
||||
x = (COLS - width)/2;
|
||||
y = (LINES - height)/2;
|
||||
|
||||
|
||||
#ifdef HAVE_NCURSES
|
||||
if (use_shadow)
|
||||
draw_shadow(stdscr, y, x, height, width);
|
||||
|
@ -156,7 +156,7 @@ int dialog_checklist(unsigned char *title, unsigned char *prompt, int height, in
|
|||
if (key < 0x100 && toupper(key) == toupper(items[(scroll+i)*3][0]))
|
||||
break;
|
||||
|
||||
if (i < max_choice || (key >= '1' && key <= MIN('9', '0'+max_choice)) ||
|
||||
if (i < max_choice || (key >= '1' && key <= MIN('9', '0'+max_choice)) ||
|
||||
key == KEY_UP || key == KEY_DOWN || key == ' ' ||
|
||||
key == '+' || key == '-' ) {
|
||||
if (key >= '1' && key <= MIN('9', '0'+max_choice))
|
||||
|
|
|
@ -44,7 +44,7 @@
|
|||
#endif
|
||||
|
||||
|
||||
/*
|
||||
/*
|
||||
* Attribute names
|
||||
*/
|
||||
#define screen_attr attributes[0]
|
||||
|
@ -115,5 +115,5 @@ void use_helpfile(char *helpfile);
|
|||
void use_helpline(char *helpline);
|
||||
char *get_helpline(void);
|
||||
void restore_helpline(char *helpline);
|
||||
void dialog_gauge(char *title, char *prompt, int y, int x,
|
||||
void dialog_gauge(char *title, char *prompt, int y, int x,
|
||||
int height, int width, int perc);
|
||||
|
|
|
@ -49,7 +49,7 @@
|
|||
|
||||
#ifndef ctrl
|
||||
#define ctrl(a) ((a) - 'a' + 1)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_NCURSES
|
||||
#ifndef ACS_ULCORNER
|
||||
|
@ -101,7 +101,7 @@ bool use_shadow = USE_SHADOW;
|
|||
#endif
|
||||
|
||||
|
||||
/*
|
||||
/*
|
||||
* Attribute values, default is for mono display
|
||||
*/
|
||||
chtype attributes[] = {
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
*
|
||||
* Program: dir.c
|
||||
* Author: Marc van Kempen
|
||||
* desc: Directory routines, sorting and reading
|
||||
* desc: Directory routines, sorting and reading
|
||||
*
|
||||
* Copyright (c) 1995, Marc van Kempen
|
||||
*
|
||||
|
@ -16,7 +16,7 @@
|
|||
* responsible for the proper functioning of this software, nor does
|
||||
* the author assume any responsibility for damages incurred with
|
||||
* its use.
|
||||
*
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
#include <sys/types.h>
|
||||
|
@ -71,7 +71,7 @@ static int _showdotfiles = TRUE;
|
|||
*
|
||||
****************************************************************************/
|
||||
|
||||
int
|
||||
int
|
||||
dir_select_nd(
|
||||
#if defined __linux__
|
||||
const struct dirent *d
|
||||
|
@ -79,8 +79,8 @@ dir_select_nd(
|
|||
struct dirent *d
|
||||
#endif
|
||||
)
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
* for the current directory and other dot-files
|
||||
* keep '..' however.
|
||||
* pre: <d> points to a dirent
|
||||
|
@ -90,13 +90,13 @@ dir_select_nd(
|
|||
if (strcmp(d->d_name, ".")==0 ||
|
||||
(d->d_name[0] == '.' && strlen(d->d_name) > 1 && d->d_name[1] != '.')) {
|
||||
return(FALSE);
|
||||
} else {
|
||||
} else {
|
||||
return(TRUE);
|
||||
}
|
||||
}/* dir_select_nd() */
|
||||
|
||||
|
||||
int
|
||||
int
|
||||
dir_select(
|
||||
#ifdef __linux__
|
||||
const struct dirent *d
|
||||
|
@ -104,8 +104,8 @@ dir_select(
|
|||
struct dirent *d
|
||||
#endif
|
||||
)
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
* for the current directory
|
||||
* pre: <d> points to a dirent
|
||||
* post: returns TRUE if d->d_name != "." else FALSE
|
||||
|
@ -118,16 +118,16 @@ dir_select(
|
|||
}
|
||||
} /* dir_select() */
|
||||
|
||||
int
|
||||
int
|
||||
dir_select_root_nd(
|
||||
#ifdef __linux__
|
||||
#ifdef __linux__
|
||||
const struct dirent *d
|
||||
#else
|
||||
struct dirent *d
|
||||
#endif
|
||||
)
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
* for the current directory and the parent directory.
|
||||
* Also skip any other dot-files.
|
||||
* pre: <d> points to a dirent
|
||||
|
@ -142,22 +142,22 @@ dir_select_root_nd(
|
|||
} /* dir_select_root_nd() */
|
||||
|
||||
|
||||
int
|
||||
int
|
||||
dir_select_root(
|
||||
#ifdef __linux__
|
||||
#ifdef __linux__
|
||||
const struct dirent *d
|
||||
#else
|
||||
struct dirent *d
|
||||
#endif
|
||||
)
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
/*
|
||||
* desc: allways include a directory entry <d>, except
|
||||
* for the current directory and the parent directory
|
||||
* pre: <d> points to a dirent
|
||||
* post: returns TRUE if d->d_name[0] != "." else FALSE
|
||||
*/
|
||||
{
|
||||
if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
|
||||
if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
|
||||
return(FALSE);
|
||||
} else {
|
||||
return(TRUE);
|
||||
|
@ -185,7 +185,7 @@ dir_alphasort(const void *d1, const void *d2)
|
|||
*
|
||||
*/
|
||||
{
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
*f2 = ((DirList *) d2);
|
||||
struct stat *s1 = &(f1->filestatus);
|
||||
struct stat *s2 = &(f2->filestatus);
|
||||
|
@ -197,7 +197,7 @@ dir_alphasort(const void *d1, const void *d2)
|
|||
if (strcmp(((DirList *) d2)->filename, "..") == 0) {
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* put directories first */
|
||||
if ((s1->st_mode & S_IFDIR) && (s2->st_mode & S_IFDIR)) {
|
||||
return(strcmp(f1->filename, f2->filename));
|
||||
|
@ -212,7 +212,7 @@ dir_alphasort(const void *d1, const void *d2)
|
|||
|
||||
} /* dir_alphasort() */
|
||||
|
||||
|
||||
|
||||
int
|
||||
dir_sizesort(const void *d1, const void *d2)
|
||||
/*
|
||||
|
@ -220,7 +220,7 @@ dir_sizesort(const void *d1, const void *d2)
|
|||
*
|
||||
*/
|
||||
{
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
*f2 = ((DirList *) d2);
|
||||
struct stat *s1 = &(f1->filestatus);
|
||||
struct stat *s2 = &(f2->filestatus);
|
||||
|
@ -232,12 +232,12 @@ dir_sizesort(const void *d1, const void *d2)
|
|||
if (strcmp(((DirList *) d2)->filename, "..") == 0) {
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* put directories first */
|
||||
if ((s1->st_mode & S_IFDIR) && (s2->st_mode & S_IFDIR)) {
|
||||
return(s1->st_size < s2->st_size ?
|
||||
-1
|
||||
:
|
||||
return(s1->st_size < s2->st_size ?
|
||||
-1
|
||||
:
|
||||
s1->st_size >= s2->st_size);
|
||||
};
|
||||
if (s1->st_mode & S_IFDIR) {
|
||||
|
@ -246,11 +246,11 @@ dir_sizesort(const void *d1, const void *d2)
|
|||
if (s2->st_mode & S_IFDIR) {
|
||||
return(1);
|
||||
}
|
||||
return(s1->st_size < s2->st_size ?
|
||||
-1
|
||||
:
|
||||
return(s1->st_size < s2->st_size ?
|
||||
-1
|
||||
:
|
||||
s1->st_size >= s2->st_size);
|
||||
|
||||
|
||||
} /* dir_sizesort() */
|
||||
|
||||
int
|
||||
|
@ -259,11 +259,11 @@ dir_datesort(const void *d1, const void *d2)
|
|||
* desc: compare d1 and d2 on date, but put directories always first
|
||||
*/
|
||||
{
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
*f2 = ((DirList *) d2);
|
||||
struct stat *s1 = &(f1->filestatus);
|
||||
struct stat *s2 = &(f2->filestatus);
|
||||
|
||||
|
||||
|
||||
/* check for '..' */
|
||||
if (strcmp(((DirList *) d1)->filename, "..") == 0) {
|
||||
|
@ -272,12 +272,12 @@ dir_datesort(const void *d1, const void *d2)
|
|||
if (strcmp(((DirList *) d2)->filename, "..") == 0) {
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* put directories first */
|
||||
if ((s1->st_mode & S_IFDIR) && (s2->st_mode & S_IFDIR)) {
|
||||
return(s1->st_mtime < s2->st_mtime ?
|
||||
-1
|
||||
:
|
||||
return(s1->st_mtime < s2->st_mtime ?
|
||||
-1
|
||||
:
|
||||
s1->st_mtime >= s2->st_mtime);
|
||||
};
|
||||
if (s1->st_mode & S_IFDIR) {
|
||||
|
@ -286,13 +286,13 @@ dir_datesort(const void *d1, const void *d2)
|
|||
if (s2->st_mode & S_IFDIR) {
|
||||
return(1);
|
||||
}
|
||||
return(s1->st_mtime < s2->st_mtime ?
|
||||
-1
|
||||
:
|
||||
return(s1->st_mtime < s2->st_mtime ?
|
||||
-1
|
||||
:
|
||||
s1->st_mtime >= s2->st_mtime);
|
||||
|
||||
} /* dir_datesort() */
|
||||
|
||||
|
||||
|
||||
int
|
||||
null_strcmp(char *s1, char *s2)
|
||||
|
@ -303,15 +303,15 @@ null_strcmp(char *s1, char *s2)
|
|||
if ((s1 == NULL) && (s2 == NULL)) {
|
||||
return(0);
|
||||
}
|
||||
if (s1 == NULL) {
|
||||
return(-1);
|
||||
if (s1 == NULL) {
|
||||
return(-1);
|
||||
}
|
||||
if (s2 == NULL) {
|
||||
return(1);
|
||||
}
|
||||
return(strcmp(s1, s2));
|
||||
} /* null_strcmp() */
|
||||
|
||||
|
||||
|
||||
int
|
||||
dir_extsort(const void *d1, const void *d2)
|
||||
|
@ -322,7 +322,7 @@ dir_extsort(const void *d1, const void *d2)
|
|||
* post: see code
|
||||
*/
|
||||
{
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
DirList *f1 = ((DirList *) d1),
|
||||
*f2 = ((DirList *) d2);
|
||||
struct stat *s1 = &(f1->filestatus);
|
||||
struct stat *s2 = &(f2->filestatus);
|
||||
|
@ -337,10 +337,10 @@ dir_extsort(const void *d1, const void *d2)
|
|||
if (strcmp(((DirList *) d2)->filename, "..") == 0) {
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* find the first extension */
|
||||
|
||||
|
||||
ext1 = f1->filename + strlen(f1->filename);
|
||||
extf = FALSE;
|
||||
while (!extf && (ext1 > f1->filename)) {
|
||||
|
@ -353,21 +353,21 @@ dir_extsort(const void *d1, const void *d2)
|
|||
}
|
||||
/* ext1 == NULL if there's no "extension" else ext1 points */
|
||||
/* to the first character of the extension string */
|
||||
|
||||
|
||||
/* find the second extension */
|
||||
|
||||
|
||||
ext2 = f2->filename + strlen(f2->filename);
|
||||
extf = FALSE;
|
||||
while (!extf && (ext2 > f2->filename)) {
|
||||
extf = (*--ext2 == '.');
|
||||
}
|
||||
}
|
||||
if (!extf) {
|
||||
ext2 = NULL;
|
||||
} else {
|
||||
ext2++;
|
||||
}
|
||||
/* idem as for ext1 */
|
||||
|
||||
|
||||
if ((s1->st_mode & S_IFDIR) && (s2->st_mode & S_IFDIR)) {
|
||||
ret = null_strcmp(ext1, ext2);
|
||||
if (ret == 0) {
|
||||
|
@ -431,7 +431,7 @@ get_dir(char *dirname, char *fmask, DirList **dir, int *n)
|
|||
/* Solution: */
|
||||
/* manually insert the parent directory as the only */
|
||||
/* directory entry, and return. */
|
||||
|
||||
|
||||
if (*n == -1) {
|
||||
*n = 1;
|
||||
*dir = (DirList *) malloc(sizeof(DirList));
|
||||
|
@ -440,7 +440,7 @@ get_dir(char *dirname, char *fmask, DirList **dir, int *n)
|
|||
(*dir)[0].filestatus = status;
|
||||
(*dir)[0].link = FALSE;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
*dir = (DirList *) malloc( *n * sizeof(DirList) );
|
||||
d = 0;
|
||||
|
@ -450,7 +450,7 @@ get_dir(char *dirname, char *fmask, DirList **dir, int *n)
|
|||
lstat(dire[j]->d_name, &status);
|
||||
/* check if this file is to be included */
|
||||
/* always include directories, the rest is subject to fmask */
|
||||
if (S_ISDIR(status.st_mode)
|
||||
if (S_ISDIR(status.st_mode)
|
||||
|| fnmatch(fmask, dire[j]->d_name, FNM_NOESCAPE) != FNM_NOMATCH) {
|
||||
strcpy((*dir)[i].filename, dire[j]->d_name);
|
||||
(*dir)[i].filestatus = status;
|
||||
|
@ -478,7 +478,7 @@ get_dir(char *dirname, char *fmask, DirList **dir, int *n)
|
|||
j++;
|
||||
}
|
||||
*n = i;
|
||||
|
||||
|
||||
/* sort the directory with the directory names on top */
|
||||
qsort((*dir), *n, sizeof(DirList), _sort_func);
|
||||
|
||||
|
@ -490,13 +490,13 @@ get_dir(char *dirname, char *fmask, DirList **dir, int *n)
|
|||
|
||||
return;
|
||||
}/* get_dir() */
|
||||
|
||||
|
||||
|
||||
void
|
||||
FreeDir(DirList *d, int n)
|
||||
/*
|
||||
* desc: free the dirlist d
|
||||
* pre: d != NULL
|
||||
* pre: d != NULL
|
||||
* post: memory allocated to d has been released
|
||||
*/
|
||||
{
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* include file for dir.c
|
||||
/*
|
||||
* include file for dir.c
|
||||
*
|
||||
* Copyright (c) 1995, Marc van Kempen
|
||||
*
|
||||
|
@ -12,7 +12,7 @@
|
|||
* responsible for the proper functioning of this software, nor does
|
||||
* the author assume any responsibility for damages incurred with
|
||||
* its use.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
|
@ -25,7 +25,7 @@ typedef struct DirList { /* structure to hold the directory entries
|
|||
int link; /* is it a link ? */
|
||||
char *linkname; /* the name of the file the link points to */
|
||||
} DirList;
|
||||
|
||||
|
||||
#ifndef TRUE
|
||||
#define TRUE (1)
|
||||
#endif
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* program: fselect.c
|
||||
* author: Marc van Kempen (wmbfmk@urc.tue.nl)
|
||||
* Desc: File selection routine
|
||||
* Desc: File selection routine
|
||||
*
|
||||
* Copyright (c) 1995, Marc van Kempen
|
||||
*
|
||||
|
@ -14,7 +14,7 @@
|
|||
* responsible for the proper functioning of this software, nor does
|
||||
* the author assume any responsibility for damages incurred with
|
||||
* its use.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
@ -31,7 +31,7 @@
|
|||
|
||||
char *dialog_dfselect(char *dir, char *fmask, int is_fselect);
|
||||
|
||||
/*
|
||||
/*
|
||||
* Functions
|
||||
*/
|
||||
|
||||
|
@ -60,7 +60,7 @@ get_directories(DirList *d, int n, char ***names, int *nd)
|
|||
void
|
||||
get_filenames(DirList *d, int n, char ***names, int *nf)
|
||||
/*
|
||||
* Desc: return the filenames in <dir> as an arry in
|
||||
* Desc: return the filenames in <dir> as an arry in
|
||||
* <names>, the # of entries in <nf>, memory allocated
|
||||
* to *names should be freed when done.
|
||||
*/
|
||||
|
@ -78,7 +78,7 @@ get_filenames(DirList *d, int n, char ***names, int *nf)
|
|||
(*names)[i] = (char *) malloc( strlen(d[i+nd].filename) + 1);
|
||||
strcpy((*names)[i], d[i+nd].filename);
|
||||
}
|
||||
|
||||
|
||||
return;
|
||||
} /* get_filenames() */
|
||||
|
||||
|
@ -102,8 +102,8 @@ FreeNames(char **names, int n)
|
|||
int
|
||||
dialog_dselect_old(void)
|
||||
/*
|
||||
* Desc: starting from the current directory,
|
||||
* choose a new current directory
|
||||
* Desc: starting from the current directory,
|
||||
* choose a new current directory
|
||||
*/
|
||||
{
|
||||
DirList *d = NULL;
|
||||
|
@ -114,12 +114,12 @@ dialog_dselect_old(void)
|
|||
StringObj *dir_obj;
|
||||
char o_dir[MAXPATHLEN];
|
||||
struct ComposeObj *obj = NULL;
|
||||
int n, nd, okbutton, cancelbutton,
|
||||
int n, nd, okbutton, cancelbutton,
|
||||
quit, cancel, ret;
|
||||
|
||||
ds_win = newwin(LINES-8, COLS-30, 4, 15);
|
||||
if (ds_win == NULL) {
|
||||
fprintf(stderr, "\nnewwin(%d,%d,%d,%d) failed, maybe wrong dims\n",
|
||||
fprintf(stderr, "\nnewwin(%d,%d,%d,%d) failed, maybe wrong dims\n",
|
||||
LINES-8, COLS-30, 4, 15);
|
||||
exit(1);
|
||||
}
|
||||
|
@ -137,7 +137,7 @@ dialog_dselect_old(void)
|
|||
/* the list of directories */
|
||||
get_dir(".", "*", &d, &n);
|
||||
get_directories(d, n, &names, &nd);
|
||||
dirs_obj = NewListObj(ds_win, "Directories:", names, o_dir, 5, 2,
|
||||
dirs_obj = NewListObj(ds_win, "Directories:", names, o_dir, 5, 2,
|
||||
LINES-15, COLS-48, nd);
|
||||
AddObj(&obj, LISTOBJ, (void *) dirs_obj);
|
||||
|
||||
|
@ -145,7 +145,7 @@ dialog_dselect_old(void)
|
|||
okbutton = FALSE;
|
||||
okbut = NewButtonObj(ds_win, "Continue", &okbutton, 7, COLS-45);
|
||||
AddObj(&obj, BUTTONOBJ, (void *) okbut);
|
||||
|
||||
|
||||
/* the Cancel-button */
|
||||
cancelbutton = FALSE;
|
||||
cancelbut = NewButtonObj(ds_win, "Return", &cancelbutton, 11, COLS-44);
|
||||
|
@ -176,7 +176,7 @@ dialog_dselect_old(void)
|
|||
strcpy(old_dir, o_dir);
|
||||
RefreshStringObj(dir_obj);
|
||||
}
|
||||
}
|
||||
}
|
||||
get_dir(".", "*", &d, &n);
|
||||
FreeNames(names, nd);
|
||||
get_directories(d, n, &names, &nd);
|
||||
|
@ -194,7 +194,7 @@ dialog_dselect_old(void)
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
FreeNames(names, nd);
|
||||
DelObj(obj);
|
||||
delwin(ds_win);
|
||||
|
@ -229,7 +229,7 @@ char *
|
|||
dialog_dfselect(char *dir, char *fmask, int is_fselect)
|
||||
/*
|
||||
* Desc: choose a file from the directory <dir>, which
|
||||
* initially display files with the mask <filemask>
|
||||
* initially display files with the mask <filemask>
|
||||
* pre: <dir> is the initial directory
|
||||
* only files corresponding to the mask <fmask> are displayed
|
||||
* post: returns NULL if no file was selected
|
||||
|
@ -262,7 +262,7 @@ dialog_dfselect(char *dir, char *fmask, int is_fselect)
|
|||
fs_win = newwin(LINES-2, COLS-20, 1, 10);
|
||||
if (fs_win == NULL) {
|
||||
endwin();
|
||||
fprintf(stderr, "\nnewwin(%d,%d,%d,%d) failed, maybe wrong dims\n",
|
||||
fprintf(stderr, "\nnewwin(%d,%d,%d,%d) failed, maybe wrong dims\n",
|
||||
LINES-2, COLS-20, 2, 10);
|
||||
exit(1);
|
||||
}
|
||||
|
@ -289,7 +289,7 @@ dialog_dfselect(char *dir, char *fmask, int is_fselect)
|
|||
get_dir(".", fmask, &d, &n); /* read the entire directory */
|
||||
get_directories(d, n, &dnames, &nd); /* extract the dir-entries */
|
||||
if (is_fselect) {
|
||||
dirs_obj = NewListObj(fs_win, "Directories:", dnames, o_dir, 5, 2,
|
||||
dirs_obj = NewListObj(fs_win, "Directories:", dnames, o_dir, 5, 2,
|
||||
LINES-16, (COLS-20)/2-2, nd);
|
||||
} else {
|
||||
dirs_obj = NewListObj(fs_win, "Directories:", dnames, o_dir, 5, 2,
|
||||
|
@ -340,7 +340,7 @@ dialog_dfselect(char *dir, char *fmask, int is_fselect)
|
|||
switch(ret) {
|
||||
case SEL_CR:
|
||||
if (strcmp(old_fmask, o_fm) || strcmp(old_dir, o_dir)) {
|
||||
/* reread directory and update the listobjects */
|
||||
/* reread directory and update the listobjects */
|
||||
if (strcmp(old_dir, o_dir)) { /* dir entry was changed */
|
||||
if (chdir(o_dir)) {
|
||||
dialog_notify("Could not change into directory");
|
||||
|
|
|
@ -20,7 +20,7 @@
|
|||
#include "dialog.h"
|
||||
|
||||
void
|
||||
dialog_gauge(char *title, char *prompt, int y, int x,
|
||||
dialog_gauge(char *title, char *prompt, int y, int x,
|
||||
int height, int width, int perc)
|
||||
/*
|
||||
* Desc: display a progress bar, progress indicated by <perc>
|
||||
|
@ -36,7 +36,7 @@ dialog_gauge(char *title, char *prompt, int y, int x,
|
|||
height, width, y, x);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
|
||||
draw_box(gw, 0, 0, height, width, dialog_attr, border_attr);
|
||||
draw_shadow(stdscr, y, x, height, width);
|
||||
|
||||
|
@ -69,4 +69,4 @@ dialog_gauge(char *title, char *prompt, int y, int x,
|
|||
|
||||
return;
|
||||
} /* dialog_gauge() */
|
||||
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/***************************************************************
|
||||
*
|
||||
*
|
||||
* Program: help.c
|
||||
* Author: Marc van Kempen
|
||||
* Desc: get help
|
||||
|
@ -16,7 +16,7 @@
|
|||
* responsible for the proper functioning of this software, nor does
|
||||
* the author assume any responsibility for damages incurred with
|
||||
* its use.
|
||||
*
|
||||
*
|
||||
***************************************************************/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
@ -111,7 +111,7 @@ display_helpfile(void)
|
|||
|
||||
return;
|
||||
} /* display_helpfile() */
|
||||
|
||||
|
||||
|
||||
/******************************************************************
|
||||
*
|
||||
|
@ -121,7 +121,7 @@ display_helpfile(void)
|
|||
|
||||
void
|
||||
use_helpline(char *hline)
|
||||
/*
|
||||
/*
|
||||
* desc: set the helpline to printed in dialogs
|
||||
*/
|
||||
{
|
||||
|
@ -177,7 +177,7 @@ get_helpline(void)
|
|||
} else {
|
||||
hlp = NULL;
|
||||
}
|
||||
|
||||
|
||||
return(hlp);
|
||||
} /* get_helpline() */
|
||||
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
* 19/12/93 - menu will now scroll if there are more items than can fit
|
||||
* on the screen.
|
||||
* - added 'checklist', a dialog box with a list of options that
|
||||
* can be turned on or off. A list of options that are on is
|
||||
* can be turned on or off. A list of options that are on is
|
||||
* returned on exit.
|
||||
*
|
||||
* 20/12/93 - Version 0.15 released.
|
||||
|
@ -67,7 +67,7 @@
|
|||
* 13/01/94 - some changes for easier porting to other Unix systems (tested
|
||||
* on Ultrix, SunOS and HPUX)
|
||||
* - Version 0.3 released.
|
||||
*
|
||||
*
|
||||
* 08/06/94 - Patches by Stuart Herbert - S.Herbert@shef.ac.uk
|
||||
* Fixed attr_clear and the textbox stuff to work with ncurses 1.8.5
|
||||
* Fixed the wordwrap routine - it'll actually wrap properly now
|
||||
|
|
|
@ -71,7 +71,7 @@ int dialog_menu(unsigned char *title, unsigned char *prompt, int height, int wid
|
|||
/* center dialog box on screen */
|
||||
x = (COLS - width)/2;
|
||||
y = (LINES - height)/2;
|
||||
|
||||
|
||||
#ifdef HAVE_NCURSES
|
||||
if (use_shadow)
|
||||
draw_shadow(stdscr, y, x, height, width);
|
||||
|
@ -149,7 +149,7 @@ int dialog_menu(unsigned char *title, unsigned char *prompt, int height, int wid
|
|||
if (key < 0x100 && toupper(key) == toupper(items[(scroll+i)*2][0]))
|
||||
break;
|
||||
|
||||
if (i < max_choice || (key >= '1' && key <= MIN('9', '0'+max_choice)) ||
|
||||
if (i < max_choice || (key >= '1' && key <= MIN('9', '0'+max_choice)) ||
|
||||
key == KEY_UP || key == KEY_DOWN || key == '-' || key == '+') {
|
||||
if (key >= '1' && key <= MIN('9', '0'+max_choice))
|
||||
i = key - '1';
|
||||
|
@ -245,7 +245,7 @@ int dialog_menu(unsigned char *title, unsigned char *prompt, int height, int wid
|
|||
*ch = choice;
|
||||
if (sc)
|
||||
*sc = scroll;
|
||||
|
||||
|
||||
switch (key) {
|
||||
case KEY_PPAGE:
|
||||
if (scroll > height-4) { /* can we go up? */
|
||||
|
@ -316,7 +316,7 @@ int dialog_menu(unsigned char *title, unsigned char *prompt, int height, int wid
|
|||
}
|
||||
if (redraw_menu) {
|
||||
for (i = 0; i < max_choice; i++) {
|
||||
print_item(menu, items[(scroll+i)*2],
|
||||
print_item(menu, items[(scroll+i)*2],
|
||||
items[(scroll+i)*2 + 1], i, i == choice);
|
||||
}
|
||||
wnoutrefresh(menu);
|
||||
|
|
|
@ -226,7 +226,7 @@ dialog_mesgbox(unsigned char *title, unsigned char *prompt, int height, int widt
|
|||
display_helpfile();
|
||||
break;
|
||||
}
|
||||
print_page(dialog, theight, width, prompt, startline, hscroll);
|
||||
print_page(dialog, theight, width, prompt, startline, hscroll);
|
||||
print_perc(dialog, height-3, width-9, (float) (startline+theight)/max_lines);
|
||||
wmove(dialog, height-2, width/2-2);
|
||||
wrefresh(dialog);
|
||||
|
@ -284,7 +284,7 @@ getline(unsigned char *buf, int n)
|
|||
if (n<0) {
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
|
||||
i=0;
|
||||
while (*buf && i<n) {
|
||||
if (*buf == '\n' || *buf == '\r') {
|
||||
|
@ -315,7 +315,7 @@ print_page(WINDOW *win, int height, int width, unsigned char *buf, int startline
|
|||
wmove(win, 1+i, 1);
|
||||
for (j=0; j<width-2; j++) waddnstr(win, " ", 1);
|
||||
wmove(win, 1+i, 1);
|
||||
j = 0;
|
||||
j = 0;
|
||||
/* scroll to the right */
|
||||
while (*b && (*b != '\n') && (*b != '\r') && (j<hscroll)) {
|
||||
b++;
|
||||
|
@ -336,7 +336,7 @@ print_page(WINDOW *win, int height, int width, unsigned char *buf, int startline
|
|||
if (*b) b++; /* skip over '\n', if it exists */
|
||||
}
|
||||
} /* print_page() */
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -14,7 +14,7 @@
|
|||
* responsible for the proper functioning of this software, nor does
|
||||
* the author assume any responsibility for damages incurred with
|
||||
* its use.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
|
@ -23,7 +23,7 @@
|
|||
|
||||
void
|
||||
dialog_notify(char *msg)
|
||||
/*
|
||||
/*
|
||||
* Desc: display an error message
|
||||
*/
|
||||
{
|
||||
|
|
|
@ -87,7 +87,7 @@ int dialog_radiolist(unsigned char *title, unsigned char *prompt, int height, in
|
|||
/* center dialog box on screen */
|
||||
x = (COLS - width)/2;
|
||||
y = (LINES - height)/2;
|
||||
|
||||
|
||||
#ifdef HAVE_NCURSES
|
||||
if (use_shadow)
|
||||
draw_shadow(stdscr, y, x, height, width);
|
||||
|
@ -164,7 +164,7 @@ int dialog_radiolist(unsigned char *title, unsigned char *prompt, int height, in
|
|||
if (toupper(key) == toupper(items[(scroll+i)*3][0]))
|
||||
break;
|
||||
|
||||
if (i < max_choice || (key >= '1' && key <= MIN('9', '0'+max_choice)) ||
|
||||
if (i < max_choice || (key >= '1' && key <= MIN('9', '0'+max_choice)) ||
|
||||
key == KEY_UP || key == KEY_DOWN || key == ' ' ||
|
||||
key == '+' || key == '-' ) {
|
||||
if (key >= '1' && key <= MIN('9', '0'+max_choice))
|
||||
|
|
|
@ -53,8 +53,8 @@ static struct pid {
|
|||
struct pid *next;
|
||||
FILE *fp;
|
||||
pid_t pid;
|
||||
} *pidlist;
|
||||
|
||||
} *pidlist;
|
||||
|
||||
FILE *
|
||||
raw_popen(const char *program, char * const *argv, const char *type)
|
||||
{
|
||||
|
@ -155,6 +155,6 @@ raw_pclose(FILE *iop)
|
|||
else
|
||||
last->next = cur->next;
|
||||
free(cur);
|
||||
|
||||
|
||||
return (pid == -1 ? -1 : pstat.w_status);
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
* Author: Marc van Kempen
|
||||
* Desc: Implementation of UI-objects:
|
||||
* - String input fields
|
||||
* - List selection
|
||||
* - List selection
|
||||
* - Buttons
|
||||
*
|
||||
* Copyright (c) 1995, Marc van Kempen
|
||||
|
@ -17,7 +17,7 @@
|
|||
* responsible for the proper functioning of this software, nor does
|
||||
* the author assume any responsibility for damages incurred with
|
||||
* its use.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
@ -79,14 +79,14 @@ FreeObj(ComposeObj *Obj)
|
|||
*/
|
||||
{
|
||||
ComposeObj *o = Obj;
|
||||
|
||||
|
||||
o = Obj;
|
||||
while (o) {
|
||||
o = Obj->next;
|
||||
free(Obj);
|
||||
Obj = o;
|
||||
}
|
||||
|
||||
|
||||
return;
|
||||
} /* FreeObj() */
|
||||
|
||||
|
@ -94,7 +94,7 @@ FreeObj(ComposeObj *Obj)
|
|||
int
|
||||
ReadObj(ComposeObj *Obj)
|
||||
/*
|
||||
* Desc: navigate through the different objects calling their
|
||||
* Desc: navigate through the different objects calling their
|
||||
* respective navigation routines as necessary
|
||||
* Pre: Obj != NULL
|
||||
*/
|
||||
|
@ -145,7 +145,7 @@ ReadObj(ComposeObj *Obj)
|
|||
}
|
||||
|
||||
return(ret);
|
||||
|
||||
|
||||
} /* ReadObj() */
|
||||
|
||||
|
||||
|
@ -225,7 +225,7 @@ DelObj(ComposeObj *Obj)
|
|||
|
||||
FreeObj(o);
|
||||
} /* DelObj() */
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* StringObj routines
|
||||
|
@ -265,7 +265,7 @@ NewStringObj(WINDOW *win, char *title, char *s, int y, int x, int w, int len)
|
|||
*/
|
||||
{
|
||||
StringObj *so;
|
||||
|
||||
|
||||
/* Initialize a new object */
|
||||
so = (StringObj *) malloc( sizeof(StringObj) );
|
||||
if (!so) {
|
||||
|
@ -302,7 +302,7 @@ SelectStringObj(StringObj *so)
|
|||
char tmp[so->len+1];
|
||||
|
||||
strcpy(tmp, so->s);
|
||||
key = line_edit(so->win, so->y+2, so->x+1,
|
||||
key = line_edit(so->win, so->y+2, so->x+1,
|
||||
so->len, so->w-2, inputbox_attr, TRUE, tmp);
|
||||
if ((key == '\n') || (key == '\r') || (key == '\t') || key == (KEY_BTAB) ) {
|
||||
strcpy(so->s, tmp);
|
||||
|
@ -335,7 +335,7 @@ DelStringObj(StringObj *so)
|
|||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
*
|
||||
* ListObj routines
|
||||
|
@ -377,7 +377,7 @@ DrawNames(ListObj *lo)
|
|||
i++;
|
||||
}
|
||||
|
||||
return;
|
||||
return;
|
||||
} /* DrawNames() */
|
||||
|
||||
void
|
||||
|
@ -401,12 +401,12 @@ RefreshListObj(ListObj *lo)
|
|||
sprintf(perc, "(%3d%%)", MIN(100, (int) (100 * (lo->sel+lo->h-2) / MAX(1, lo->n))));
|
||||
wmove(lo->win, lo->y + lo->h, lo->x + lo->w - 8);
|
||||
wattrset(lo->win, dialog_attr);
|
||||
waddstr(lo->win, perc);
|
||||
|
||||
|
||||
waddstr(lo->win, perc);
|
||||
|
||||
|
||||
return;
|
||||
} /* RefreshListObj() */
|
||||
|
||||
|
||||
ListObj *
|
||||
NewListObj(WINDOW *win, char *title, char **list, char *listelt, int y, int x,
|
||||
int h, int w, int n)
|
||||
|
@ -485,7 +485,7 @@ UpdateListObj(ListObj *lo, char **list, int n)
|
|||
}
|
||||
} else {
|
||||
lo->seld = NULL;
|
||||
}
|
||||
}
|
||||
lo->n = n;
|
||||
lo->scroll = 0;
|
||||
lo->sel = 0;
|
||||
|
@ -521,7 +521,7 @@ SelectListObj(ListObj *lo)
|
|||
|
||||
key = wgetch(lo->win);
|
||||
quit = FALSE;
|
||||
while ((key != '\t') && (key != '\n') && (key != '\r')
|
||||
while ((key != '\t') && (key != '\n') && (key != '\r')
|
||||
&& (key != ESC) && (key != KEY_F(1)) && (key != '?') && !quit) {
|
||||
/* first draw current item in normal video */
|
||||
wmove(lo->win, sel_y, sel_x);
|
||||
|
@ -620,11 +620,11 @@ SelectListObj(ListObj *lo)
|
|||
break;
|
||||
}
|
||||
/* Draw % indication */
|
||||
sprintf(perc, "(%3d%%)", MIN(100, (int)
|
||||
sprintf(perc, "(%3d%%)", MIN(100, (int)
|
||||
(100 * (lo->sel+lo->h - 2) / MAX(1, lo->n))));
|
||||
wmove(lo->win, lo->y + lo->h, lo->x + lo->w - 8);
|
||||
wattrset(lo->win, dialog_attr);
|
||||
waddstr(lo->win, perc);
|
||||
waddstr(lo->win, perc);
|
||||
|
||||
/* draw current item in inverse */
|
||||
wmove(lo->win, sel_y, sel_x);
|
||||
|
@ -632,8 +632,8 @@ SelectListObj(ListObj *lo)
|
|||
if (strlen(lo->name[lo->sel]) > lo->w - 2) {
|
||||
/* when printing in inverse video show the last characters in the */
|
||||
/* name that will fit in the window */
|
||||
strncpy(tmp,
|
||||
lo->name[lo->sel] + strlen(lo->name[lo->sel]) - (lo->w - 2),
|
||||
strncpy(tmp,
|
||||
lo->name[lo->sel] + strlen(lo->name[lo->sel]) - (lo->w - 2),
|
||||
lo->w - 2);
|
||||
tmp[lo->w - 2] = 0;
|
||||
waddstr(lo->win, tmp);
|
||||
|
@ -642,7 +642,7 @@ SelectListObj(ListObj *lo)
|
|||
}
|
||||
if (!quit) key = wgetch(lo->win);
|
||||
}
|
||||
|
||||
|
||||
if (key == ESC) {
|
||||
return(SEL_ESC);
|
||||
}
|
||||
|
@ -674,8 +674,8 @@ DelListObj(ListObj *lo)
|
|||
|
||||
void
|
||||
MarkCurrentListObj(ListObj *lo)
|
||||
/*
|
||||
* Desc: mark the current item for the selection list
|
||||
/*
|
||||
* Desc: mark the current item for the selection list
|
||||
*/
|
||||
{
|
||||
lo->seld[lo->sel] = !(lo->seld[lo->sel]);
|
||||
|
@ -707,7 +707,7 @@ UnMarkAllListObj(ListObj *lo)
|
|||
*/
|
||||
{
|
||||
int i;
|
||||
|
||||
|
||||
for (i=0; i<lo->n; i++) {
|
||||
lo->seld[i] = FALSE;
|
||||
}
|
||||
|
@ -745,7 +745,7 @@ NewButtonObj(WINDOW *win, char *title, int *pushed, int y, int x)
|
|||
ButtonObj *bo;
|
||||
|
||||
bo = (ButtonObj *) malloc( sizeof(ButtonObj) );
|
||||
|
||||
|
||||
bo->win = win;
|
||||
bo->title = (char *) malloc( strlen(title) + 1);
|
||||
strcpy(bo->title, title);
|
||||
|
@ -771,7 +771,7 @@ SelectButtonObj(ButtonObj *bo)
|
|||
print_button(bo->win, bo->title, bo->y+1, bo->x+2, TRUE);
|
||||
wmove(bo->win, bo->y+1, bo->x+(bo->w/2)-1);
|
||||
key = wgetch(bo->win);
|
||||
print_button(bo->win, bo->title, bo->y+1, bo->x+2, FALSE);
|
||||
print_button(bo->win, bo->title, bo->y+1, bo->x+2, FALSE);
|
||||
switch(key) {
|
||||
case '\t':
|
||||
return(SEL_TAB);
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
* responsible for the proper functioning of this software, nor does
|
||||
* the author assume any responsibility for damages incurred with
|
||||
* its use.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#include "dialog.h"
|
||||
|
@ -85,13 +85,13 @@ typedef struct ComposeObj {
|
|||
**********************************************************************/
|
||||
|
||||
void RefreshStringObj(StringObj *so);
|
||||
StringObj *NewStringObj(WINDOW *win, char *title, char *s,
|
||||
StringObj *NewStringObj(WINDOW *win, char *title, char *s,
|
||||
int y, int x, int w, int len);
|
||||
int SelectStringObj(StringObj *so);
|
||||
void DelStringObj(StringObj *so);
|
||||
|
||||
void RefreshListObj(ListObj *lo);
|
||||
ListObj *NewListObj(WINDOW *win, char *title, char **list,
|
||||
ListObj *NewListObj(WINDOW *win, char *title, char **list,
|
||||
char *listelt, int y, int x, int h, int w, int n);
|
||||
void UpdateListObj(ListObj *lo, char **list, int n);
|
||||
int SelectListObj(ListObj *lo);
|
||||
|
@ -101,7 +101,7 @@ void MarkAllListObj(ListObj *lo);
|
|||
void UnMarkAllListObj(ListObj *lo);
|
||||
|
||||
void RefreshButtonObj(ButtonObj *bo);
|
||||
ButtonObj *NewButtonObj(WINDOW *win, char *title, int *pushed,
|
||||
ButtonObj *NewButtonObj(WINDOW *win, char *title, int *pushed,
|
||||
int y, int x);
|
||||
int SelectButtonObj(ButtonObj *bo);
|
||||
void DelButtonObj(ButtonObj *bo);
|
||||
|
|
|
@ -52,7 +52,7 @@ int dialog_yesno(unsigned char *title, unsigned char * prompt, int height, int w
|
|||
/* center dialog box on screen */
|
||||
x = (COLS - width)/2;
|
||||
y = (LINES - height)/2;
|
||||
|
||||
|
||||
#ifdef HAVE_NCURSES
|
||||
if (use_shadow)
|
||||
draw_shadow(stdscr, y, x, height, width);
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -16,7 +16,7 @@ License along with this library; if not, write to the Free Software
|
|||
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
#ifndef _ACG_h
|
||||
#define _ACG_h 1
|
||||
#define _ACG_h 1
|
||||
|
||||
#include <RNG.h>
|
||||
#include <math.h>
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1989 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -25,7 +25,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
|
||||
|
||||
/*
|
||||
An AllocRing holds the last n malloc'ed strings, reallocating/reusing
|
||||
An AllocRing holds the last n malloc'ed strings, reallocating/reusing
|
||||
one only when the queue wraps around. It thus guarantees that the
|
||||
last n allocations are intact. It is useful for things like I/O
|
||||
formatting where reasonable restrictions may be made about the
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -36,11 +36,11 @@ struct BitSetRep
|
|||
unsigned short s[1]; // bits start here
|
||||
};
|
||||
|
||||
extern BitSetRep* BitSetalloc(BitSetRep*, const unsigned short*,
|
||||
extern BitSetRep* BitSetalloc(BitSetRep*, const unsigned short*,
|
||||
int, int, int);
|
||||
extern BitSetRep* BitSetcopy(BitSetRep*, const BitSetRep*);
|
||||
extern BitSetRep* BitSetresize(BitSetRep*, int);
|
||||
extern BitSetRep* BitSetop(const BitSetRep*, const BitSetRep*,
|
||||
extern BitSetRep* BitSetop(const BitSetRep*, const BitSetRep*,
|
||||
BitSetRep*, char);
|
||||
extern BitSetRep* BitSetcmpl(const BitSetRep*, BitSetRep*);
|
||||
|
||||
|
@ -69,7 +69,7 @@ class BitSet
|
|||
protected:
|
||||
BitSetRep* rep;
|
||||
|
||||
|
||||
|
||||
public:
|
||||
|
||||
// constructors
|
||||
|
@ -116,7 +116,7 @@ class BitSet
|
|||
int test(int from, int to) const;
|
||||
|
||||
BitSetBit operator [] (int i);
|
||||
|
||||
|
||||
// iterators
|
||||
|
||||
int first(int b = 1) const;
|
||||
|
@ -132,13 +132,13 @@ class BitSet
|
|||
int empty() const;
|
||||
int virtual_bit() const;
|
||||
int count(int b = 1) const;
|
||||
|
||||
|
||||
// convertors & IO
|
||||
|
||||
friend BitSet atoBitSet(const char* s,
|
||||
friend BitSet atoBitSet(const char* s,
|
||||
char f='0', char t='1', char star='*');
|
||||
// BitSettoa is deprecated; do not use in new programs.
|
||||
friend const char* BitSettoa(const BitSet& x,
|
||||
friend const char* BitSettoa(const BitSet& x,
|
||||
char f='0', char t='1', char star='*');
|
||||
|
||||
friend BitSet shorttoBitSet(unsigned short w);
|
||||
|
@ -193,7 +193,7 @@ inline BitSet::BitSet(const BitSet& x) :rep(BitSetcopy(0, x.rep)) {}
|
|||
inline BitSet::~BitSet() { if (rep != &_nilBitSetRep) delete rep; }
|
||||
|
||||
inline BitSet& BitSet::operator = (const BitSet& y)
|
||||
{
|
||||
{
|
||||
rep = BitSetcopy(rep, y.rep);
|
||||
return *this;
|
||||
}
|
||||
|
@ -258,27 +258,27 @@ inline BitSet operator ~ (const BitSet& x) return r
|
|||
|
||||
#else /* NO_NRV */
|
||||
|
||||
inline BitSet operator & (const BitSet& x, const BitSet& y)
|
||||
inline BitSet operator & (const BitSet& x, const BitSet& y)
|
||||
{
|
||||
BitSet r; and(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitSet operator | (const BitSet& x, const BitSet& y)
|
||||
inline BitSet operator | (const BitSet& x, const BitSet& y)
|
||||
{
|
||||
BitSet r; or(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitSet operator ^ (const BitSet& x, const BitSet& y)
|
||||
inline BitSet operator ^ (const BitSet& x, const BitSet& y)
|
||||
{
|
||||
BitSet r; xor(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitSet operator - (const BitSet& x, const BitSet& y)
|
||||
inline BitSet operator - (const BitSet& x, const BitSet& y)
|
||||
{
|
||||
BitSet r; diff(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitSet operator ~ (const BitSet& x)
|
||||
inline BitSet operator ~ (const BitSet& x)
|
||||
{
|
||||
BitSet r; ::complement(x, r); return r;
|
||||
}
|
||||
|
@ -329,7 +329,7 @@ inline int BitSet::test(int p) const
|
|||
{
|
||||
if (p < 0) error("Illegal bit index");
|
||||
int index = BitSet_index(p);
|
||||
return (index >= rep->len)? rep->virt :
|
||||
return (index >= rep->len)? rep->virt :
|
||||
((rep->s[index] & (1 << BitSet_pos(p))) != 0);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -138,7 +138,7 @@ class BitString
|
|||
|
||||
friend void complement(const BitString&, BitString&);
|
||||
|
||||
friend int lcompare(const BitString&, const BitString&);
|
||||
friend int lcompare(const BitString&, const BitString&);
|
||||
|
||||
// assignment-based operators
|
||||
// (constuctive versions decalred inline below
|
||||
|
@ -162,7 +162,7 @@ class BitString
|
|||
|
||||
void clear(int pos);
|
||||
void clear(int from, int to);
|
||||
void clear();
|
||||
void clear();
|
||||
|
||||
void invert(int pos);
|
||||
void invert(int from, int to);
|
||||
|
@ -188,7 +188,7 @@ class BitString
|
|||
|
||||
// searching & matching
|
||||
|
||||
int index(unsigned int bit, int startpos = 0) const ;
|
||||
int index(unsigned int bit, int startpos = 0) const ;
|
||||
int index(const BitString&, int startpos = 0) const;
|
||||
int index(const BitSubString&, int startpos = 0) const;
|
||||
int index(const BitPattern&, int startpos = 0) const;
|
||||
|
@ -208,9 +208,9 @@ class BitString
|
|||
// BitSubString extraction
|
||||
|
||||
BitSubString at(int pos, int len);
|
||||
BitSubString at(const BitString&, int startpos = 0);
|
||||
BitSubString at(const BitSubString&, int startpos = 0);
|
||||
BitSubString at(const BitPattern&, int startpos = 0);
|
||||
BitSubString at(const BitString&, int startpos = 0);
|
||||
BitSubString at(const BitSubString&, int startpos = 0);
|
||||
BitSubString at(const BitPattern&, int startpos = 0);
|
||||
|
||||
BitSubString before(int pos);
|
||||
BitSubString before(const BitString&, int startpos = 0);
|
||||
|
@ -224,9 +224,9 @@ class BitString
|
|||
|
||||
// other friends & utilities
|
||||
|
||||
friend BitString common_prefix(const BitString&, const BitString&,
|
||||
friend BitString common_prefix(const BitString&, const BitString&,
|
||||
int pos = 0);
|
||||
friend BitString common_suffix(const BitString&, const BitString&,
|
||||
friend BitString common_suffix(const BitString&, const BitString&,
|
||||
int pos = -1);
|
||||
friend BitString reverse(const BitString&);
|
||||
|
||||
|
@ -259,7 +259,7 @@ class BitString
|
|||
|
||||
friend BitPattern atoBitPattern(const char* s,
|
||||
char f='0',char t='1',char x='X');
|
||||
friend const char* BitPatterntoa(const BitPattern& p,
|
||||
friend const char* BitPatterntoa(const BitPattern& p,
|
||||
char f='0',char t='1',char x='X');
|
||||
int OK() const;
|
||||
};
|
||||
|
@ -277,7 +277,7 @@ class BitPattern
|
|||
|
||||
~BitPattern();
|
||||
|
||||
friend const char* BitPatterntoa(const BitPattern& p,
|
||||
friend const char* BitPatterntoa(const BitPattern& p,
|
||||
char f/*='0'*/,char t/*='1'*/,char x/*='X'*/);
|
||||
void printon(ostream&, char f='0',char t='1',char x='X') const;
|
||||
friend BitPattern atoBitPattern(const char* s, char f,char t, char x);
|
||||
|
@ -320,16 +320,16 @@ inline BitString::BitString() :rep(&_nilBitStrRep) {}
|
|||
|
||||
inline BitString::BitString(const BitString& x) :rep(BStr_copy(0, x.rep)) {}
|
||||
|
||||
inline BitString::BitString(const BitSubString& y)
|
||||
inline BitString::BitString(const BitSubString& y)
|
||||
:rep (BStr_alloc(0, y.S.rep->s, y.pos, y.pos+y.len, y.len)) {}
|
||||
|
||||
inline BitString::~BitString()
|
||||
{
|
||||
{
|
||||
if (rep != &_nilBitStrRep) delete rep;
|
||||
}
|
||||
|
||||
inline BitString shorttoBitString(unsigned short w)
|
||||
{
|
||||
inline BitString shorttoBitString(unsigned short w)
|
||||
{
|
||||
BitString r;
|
||||
_BS_word ww = w;
|
||||
#if _BS_BIGENDIAN
|
||||
|
@ -339,8 +339,8 @@ inline BitString shorttoBitString(unsigned short w)
|
|||
return r;
|
||||
}
|
||||
|
||||
inline BitString longtoBitString(unsigned long w)
|
||||
{
|
||||
inline BitString longtoBitString(unsigned long w)
|
||||
{
|
||||
BitString r;
|
||||
#if 1
|
||||
_BS_word u = w;
|
||||
|
@ -355,13 +355,13 @@ inline BitString longtoBitString(unsigned long w)
|
|||
}
|
||||
|
||||
inline BitString& BitString::operator = (const BitString& y)
|
||||
{
|
||||
{
|
||||
rep = BStr_copy(rep, y.rep);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline BitString& BitString::operator = (unsigned int b)
|
||||
{
|
||||
{
|
||||
_BS_word bit = b;
|
||||
rep = BStr_alloc(rep, &bit, 0, 1, 1);
|
||||
return *this;
|
||||
|
@ -373,7 +373,7 @@ inline BitString& BitString::operator=(const BitSubString& y)
|
|||
return *this;
|
||||
}
|
||||
|
||||
inline BitSubString::BitSubString(const BitSubString& x)
|
||||
inline BitSubString::BitSubString(const BitSubString& x)
|
||||
:S(x.S), pos(x.pos), len(x.len) {}
|
||||
|
||||
inline BitSubString::BitSubString(BitString& x, int p, int l)
|
||||
|
@ -544,47 +544,47 @@ inline BitString operator ~ (const BitString& x) return r
|
|||
|
||||
#else /* NO_NRV */
|
||||
|
||||
inline BitString operator & (const BitString& x, const BitString& y)
|
||||
inline BitString operator & (const BitString& x, const BitString& y)
|
||||
{
|
||||
BitString r; and(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator | (const BitString& x, const BitString& y)
|
||||
inline BitString operator | (const BitString& x, const BitString& y)
|
||||
{
|
||||
BitString r; or(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator ^ (const BitString& x, const BitString& y)
|
||||
inline BitString operator ^ (const BitString& x, const BitString& y)
|
||||
{
|
||||
BitString r; xor(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator << (const BitString& x, int y)
|
||||
inline BitString operator << (const BitString& x, int y)
|
||||
{
|
||||
BitString r; lshift(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator >> (const BitString& x, int y)
|
||||
inline BitString operator >> (const BitString& x, int y)
|
||||
{
|
||||
BitString r; rshift(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator - (const BitString& x, const BitString& y)
|
||||
inline BitString operator - (const BitString& x, const BitString& y)
|
||||
{
|
||||
BitString r; diff(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator + (const BitString& x, const BitString& y)
|
||||
inline BitString operator + (const BitString& x, const BitString& y)
|
||||
{
|
||||
BitString r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator + (const BitString& x, unsigned int y)
|
||||
inline BitString operator + (const BitString& x, unsigned int y)
|
||||
{
|
||||
BitString r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline BitString operator ~ (const BitString& x)
|
||||
inline BitString operator ~ (const BitString& x)
|
||||
{
|
||||
BitString r; complement(x, r); return r;
|
||||
}
|
||||
|
@ -594,32 +594,32 @@ inline BitString operator ~ (const BitString& x)
|
|||
// status, matching
|
||||
|
||||
inline int BitString::length() const
|
||||
{
|
||||
{
|
||||
return rep->len;
|
||||
}
|
||||
|
||||
inline int BitString::empty() const
|
||||
{
|
||||
{
|
||||
return rep->len == 0;
|
||||
}
|
||||
|
||||
inline int BitString::index(const BitString& y, int startpos) const
|
||||
{
|
||||
{
|
||||
return search(startpos, rep->len, y.rep->s, 0, y.rep->len);
|
||||
}
|
||||
|
||||
inline int BitString::index(const BitSubString& y, int startpos) const
|
||||
{
|
||||
{
|
||||
return search(startpos, rep->len, y.S.rep->s, y.pos, y.pos+y.len);
|
||||
}
|
||||
|
||||
inline int BitString::contains(const BitString& y) const
|
||||
{
|
||||
{
|
||||
return search(0, rep->len, y.rep->s, 0, y.rep->len) >= 0;
|
||||
}
|
||||
|
||||
inline int BitString::contains(const BitSubString& y) const
|
||||
{
|
||||
{
|
||||
return search(0, rep->len, y.S.rep->s, y.pos, y.pos+y.len) >= 0;
|
||||
}
|
||||
|
||||
|
@ -664,12 +664,12 @@ inline int BitString::index(const BitPattern& r, int startpos) const
|
|||
}
|
||||
|
||||
inline int BitSubString::length() const
|
||||
{
|
||||
{
|
||||
return len;
|
||||
}
|
||||
|
||||
inline int BitSubString::empty() const
|
||||
{
|
||||
{
|
||||
return len == 0;
|
||||
}
|
||||
|
||||
|
@ -706,7 +706,7 @@ inline int BitString::index(unsigned int bit, int startpos) const
|
|||
return prev(rep->len + startpos + 1, bit);
|
||||
}
|
||||
|
||||
inline void BitString::right_trim(unsigned int b)
|
||||
inline void BitString::right_trim(unsigned int b)
|
||||
{
|
||||
int nb = (b == 0)? 1 : 0;
|
||||
rep = BStr_resize(rep, prev(rep->len, nb) + 1);
|
||||
|
@ -721,7 +721,7 @@ inline void BitString::left_trim(unsigned int b)
|
|||
|
||||
inline int BitString::test(int i) const
|
||||
{
|
||||
return ((unsigned)(i) >= rep->len)? 0 :
|
||||
return ((unsigned)(i) >= rep->len)? 0 :
|
||||
((rep->s[BitStr_index(i)] & (1 << (BitStr_pos(i)))) != 0);
|
||||
}
|
||||
|
||||
|
@ -754,7 +754,7 @@ inline BitSubString BitString::_substr(int first, int l)
|
|||
{
|
||||
if (first < 0 || l <= 0 || (unsigned)(first + l) > rep->len)
|
||||
return BitSubString(_nil_BitString, 0, 0) ;
|
||||
else
|
||||
else
|
||||
return BitSubString(*this, first, l);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -57,8 +57,8 @@ class Complex
|
|||
Complex& operator *= (const Complex& y);
|
||||
Complex& operator *= (double y);
|
||||
|
||||
Complex& operator /= (const Complex& y);
|
||||
Complex& operator /= (double y);
|
||||
Complex& operator /= (const Complex& y);
|
||||
Complex& operator /= (double y);
|
||||
|
||||
void error(const char* msg) const;
|
||||
};
|
||||
|
@ -83,7 +83,7 @@ Complex pow(const Complex& x, int p);
|
|||
Complex pow(const Complex& x, const Complex& p);
|
||||
Complex pow(const Complex& x, double y);
|
||||
Complex sqrt(const Complex& x);
|
||||
|
||||
|
||||
istream& operator >> (istream& s, Complex& x);
|
||||
ostream& operator << (ostream& s, const Complex& x);
|
||||
|
||||
|
@ -99,42 +99,42 @@ inline Complex::Complex(double r, double i) :re(r), im(i) {}
|
|||
|
||||
inline Complex::~Complex() {}
|
||||
|
||||
inline Complex& Complex::operator = (const Complex& y)
|
||||
{
|
||||
re = y.real(); im = y.imag(); return *this;
|
||||
}
|
||||
inline Complex& Complex::operator = (const Complex& y)
|
||||
{
|
||||
re = y.real(); im = y.imag(); return *this;
|
||||
}
|
||||
|
||||
inline Complex& Complex::operator += (const Complex& y)
|
||||
{
|
||||
re += y.real(); im += y.imag(); return *this;
|
||||
{
|
||||
re += y.real(); im += y.imag(); return *this;
|
||||
}
|
||||
|
||||
inline Complex& Complex::operator += (double y)
|
||||
{
|
||||
re += y; return *this;
|
||||
{
|
||||
re += y; return *this;
|
||||
}
|
||||
|
||||
inline Complex& Complex::operator -= (const Complex& y)
|
||||
{
|
||||
re -= y.real(); im -= y.imag(); return *this;
|
||||
{
|
||||
re -= y.real(); im -= y.imag(); return *this;
|
||||
}
|
||||
|
||||
inline Complex& Complex::operator -= (double y)
|
||||
{
|
||||
re -= y; return *this;
|
||||
{
|
||||
re -= y; return *this;
|
||||
}
|
||||
|
||||
inline Complex& Complex::operator *= (const Complex& y)
|
||||
{
|
||||
{
|
||||
double r = re * y.real() - im * y.imag();
|
||||
im = re * y.imag() + im * y.real();
|
||||
re = r;
|
||||
return *this;
|
||||
im = re * y.imag() + im * y.real();
|
||||
re = r;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Complex& Complex::operator *= (double y)
|
||||
{
|
||||
re *= y; im *= y; return *this;
|
||||
{
|
||||
re *= y; im *= y; return *this;
|
||||
}
|
||||
|
||||
|
||||
|
@ -202,7 +202,7 @@ inline Complex operator - (double x, const Complex& y)
|
|||
|
||||
inline Complex operator * (const Complex& x, const Complex& y)
|
||||
{
|
||||
return Complex(x.real() * y.real() - x.imag() * y.imag(),
|
||||
return Complex(x.real() * y.real() - x.imag() * y.imag(),
|
||||
x.real() * y.imag() + x.imag() * y.real());
|
||||
}
|
||||
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1989 Free Software Foundation
|
||||
written by Eric Newton (newton@rocky.oswego.edu)
|
||||
|
||||
|
@ -237,7 +237,7 @@ inline int (mvinsch)(int y, int x, char c)
|
|||
*
|
||||
*/
|
||||
|
||||
class CursesWindow
|
||||
class CursesWindow
|
||||
{
|
||||
protected:
|
||||
static int count; // count of all active windows:
|
||||
|
@ -385,102 +385,102 @@ inline int CursesWindow::width()
|
|||
return maxx() - begx() + 1;
|
||||
}
|
||||
|
||||
inline int CursesWindow::box(char vert, char hor)
|
||||
inline int CursesWindow::box(char vert, char hor)
|
||||
{
|
||||
return ::box(w, vert, hor);
|
||||
return ::box(w, vert, hor);
|
||||
}
|
||||
|
||||
inline int CursesWindow::overlay(CursesWindow &win)
|
||||
inline int CursesWindow::overlay(CursesWindow &win)
|
||||
{
|
||||
return ::overlay(w, win.w);
|
||||
return ::overlay(w, win.w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::overwrite(CursesWindow &win)
|
||||
inline int CursesWindow::overwrite(CursesWindow &win)
|
||||
{
|
||||
return ::overwrite(w, win.w);
|
||||
return ::overwrite(w, win.w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::scroll()
|
||||
inline int CursesWindow::scroll()
|
||||
{
|
||||
return ::scroll(w);
|
||||
return ::scroll(w);
|
||||
}
|
||||
|
||||
|
||||
inline int CursesWindow::touchwin()
|
||||
inline int CursesWindow::touchwin()
|
||||
{
|
||||
return ::touchwin(w);
|
||||
return ::touchwin(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::addch(const char ch)
|
||||
inline int CursesWindow::addch(const char ch)
|
||||
{
|
||||
return ::waddch(w, ch);
|
||||
return ::waddch(w, ch);
|
||||
}
|
||||
|
||||
inline int CursesWindow::addstr(const char * str)
|
||||
inline int CursesWindow::addstr(const char * str)
|
||||
{
|
||||
// The (char*) cast is to hack around prototypes in curses.h that
|
||||
// have const missing in the parameter lists. [E.g. SVR4]
|
||||
return ::waddstr(w, (char*)str);
|
||||
return ::waddstr(w, (char*)str);
|
||||
}
|
||||
|
||||
inline int CursesWindow::clear()
|
||||
inline int CursesWindow::clear()
|
||||
{
|
||||
return ::wclear(w);
|
||||
return ::wclear(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::clrtobot()
|
||||
inline int CursesWindow::clrtobot()
|
||||
{
|
||||
return ::wclrtobot(w);
|
||||
return ::wclrtobot(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::clrtoeol()
|
||||
inline int CursesWindow::clrtoeol()
|
||||
{
|
||||
return ::wclrtoeol(w);
|
||||
return ::wclrtoeol(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::delch()
|
||||
inline int CursesWindow::delch()
|
||||
{
|
||||
return ::wdelch(w);
|
||||
return ::wdelch(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::deleteln()
|
||||
inline int CursesWindow::deleteln()
|
||||
{
|
||||
return ::wdeleteln(w);
|
||||
return ::wdeleteln(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::erase()
|
||||
inline int CursesWindow::erase()
|
||||
{
|
||||
return ::werase(w);
|
||||
return ::werase(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::getch()
|
||||
inline int CursesWindow::getch()
|
||||
{
|
||||
return ::wgetch(w);
|
||||
return ::wgetch(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::getstr(char * str)
|
||||
inline int CursesWindow::getstr(char * str)
|
||||
{
|
||||
return ::wgetstr(w, str);
|
||||
return ::wgetstr(w, str);
|
||||
}
|
||||
|
||||
inline int CursesWindow::inch()
|
||||
inline int CursesWindow::inch()
|
||||
{
|
||||
return winch(w);
|
||||
return winch(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::insch(char c)
|
||||
inline int CursesWindow::insch(char c)
|
||||
{
|
||||
return ::winsch(w, c);
|
||||
return ::winsch(w, c);
|
||||
}
|
||||
|
||||
inline int CursesWindow::insertln()
|
||||
inline int CursesWindow::insertln()
|
||||
{
|
||||
return ::winsertln(w);
|
||||
return ::winsertln(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::move(int y, int x)
|
||||
inline int CursesWindow::move(int y, int x)
|
||||
{
|
||||
return ::wmove(w, y, x);
|
||||
return ::wmove(w, y, x);
|
||||
}
|
||||
|
||||
|
||||
|
@ -524,56 +524,56 @@ inline int CursesWindow::mvinsch(int y, int x, char ch)
|
|||
return (::wmove(w, y, x)==ERR) ? ERR : ::winsch(w, ch);
|
||||
}
|
||||
|
||||
inline int CursesWindow::refresh()
|
||||
inline int CursesWindow::refresh()
|
||||
{
|
||||
return ::wrefresh(w);
|
||||
return ::wrefresh(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::clearok(int bf)
|
||||
inline int CursesWindow::clearok(int bf)
|
||||
{
|
||||
return ::clearok(w,bf);
|
||||
return ::clearok(w,bf);
|
||||
}
|
||||
|
||||
inline int CursesWindow::leaveok(int bf)
|
||||
inline int CursesWindow::leaveok(int bf)
|
||||
{
|
||||
return ::leaveok(w,bf);
|
||||
return ::leaveok(w,bf);
|
||||
}
|
||||
|
||||
inline int CursesWindow::scrollok(int bf)
|
||||
inline int CursesWindow::scrollok(int bf)
|
||||
{
|
||||
return ::scrollok(w,bf);
|
||||
return ::scrollok(w,bf);
|
||||
}
|
||||
|
||||
#ifndef _no_flushok
|
||||
inline int CursesWindow::flushok(int bf)
|
||||
inline int CursesWindow::flushok(int bf)
|
||||
{
|
||||
return ::flushok(w, bf);
|
||||
return ::flushok(w, bf);
|
||||
}
|
||||
#endif
|
||||
|
||||
inline void CursesWindow::getyx(int& y, int& x)
|
||||
inline void CursesWindow::getyx(int& y, int& x)
|
||||
{
|
||||
::getyx(w, y, x);
|
||||
::getyx(w, y, x);
|
||||
}
|
||||
|
||||
inline int CursesWindow::standout()
|
||||
inline int CursesWindow::standout()
|
||||
{
|
||||
return ::wstandout(w);
|
||||
return ::wstandout(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::standend()
|
||||
inline int CursesWindow::standend()
|
||||
{
|
||||
return ::wstandend(w);
|
||||
return ::wstandend(w);
|
||||
}
|
||||
|
||||
inline int CursesWindow::lines()
|
||||
inline int CursesWindow::lines()
|
||||
{
|
||||
return LINES;
|
||||
return LINES;
|
||||
}
|
||||
|
||||
inline int CursesWindow::cols()
|
||||
inline int CursesWindow::cols()
|
||||
{
|
||||
return COLS;
|
||||
return COLS;
|
||||
}
|
||||
|
||||
inline CursesWindow* CursesWindow::child()
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -25,7 +25,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
|
||||
//
|
||||
// The interval [lo..hi)
|
||||
//
|
||||
//
|
||||
|
||||
class DiscreteUniform: public Random {
|
||||
long pLow;
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -19,7 +19,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
#define _Erlang_h 1
|
||||
#define _Erlang_h 1
|
||||
|
||||
#include <Random.h>
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// -*- C++ -*-
|
||||
// Fix.h : variable length fixed point data type
|
||||
// Fix.h : variable length fixed point data type
|
||||
//
|
||||
|
||||
#ifndef _Fix_h
|
||||
|
@ -124,7 +124,7 @@ class Fix
|
|||
friend char* Ftoa(const Fix&, int width = default_print_width);
|
||||
void printon(ostream&, int width = default_print_width) const;
|
||||
friend Fix atoF(const char*, int len = default_length);
|
||||
|
||||
|
||||
friend istream& operator >> (istream&, Fix&);
|
||||
friend ostream& operator << (ostream&, const Fix&);
|
||||
|
||||
|
@ -184,7 +184,7 @@ Fix::mask (Fix::Rep* x)
|
|||
{
|
||||
int n = x->len & 0x0f;
|
||||
if ( n )
|
||||
x->s[x->siz - 1] &= 0xffff0000 >> n;
|
||||
x->s[x->siz - 1] &= 0xffff0000 >> n;
|
||||
}
|
||||
|
||||
inline Fix::Rep*
|
||||
|
@ -269,7 +269,7 @@ Fix::operator = (const Fix& y)
|
|||
if ( rep->len == y.rep->len ) {
|
||||
++y.rep->ref;
|
||||
if ( --rep->ref <= 0 ) delete rep;
|
||||
rep = y.rep;
|
||||
rep = y.rep;
|
||||
}
|
||||
else {
|
||||
unique();
|
||||
|
@ -290,37 +290,37 @@ Fix::operator = (double d)
|
|||
inline int
|
||||
operator == (const Fix& x, const Fix& y)
|
||||
{
|
||||
return Fix::compare(x.rep, y.rep) == 0;
|
||||
return Fix::compare(x.rep, y.rep) == 0;
|
||||
}
|
||||
|
||||
inline int
|
||||
operator != (const Fix& x, const Fix& y)
|
||||
{
|
||||
return Fix::compare(x.rep, y.rep) != 0;
|
||||
return Fix::compare(x.rep, y.rep) != 0;
|
||||
}
|
||||
|
||||
inline int
|
||||
operator < (const Fix& x, const Fix& y)
|
||||
{
|
||||
return Fix::compare(x.rep, y.rep) < 0;
|
||||
return Fix::compare(x.rep, y.rep) < 0;
|
||||
}
|
||||
|
||||
inline int
|
||||
operator <= (const Fix& x, const Fix& y)
|
||||
{
|
||||
return Fix::compare(x.rep, y.rep) <= 0;
|
||||
return Fix::compare(x.rep, y.rep) <= 0;
|
||||
}
|
||||
|
||||
inline int
|
||||
operator > (const Fix& x, const Fix& y)
|
||||
{
|
||||
return Fix::compare(x.rep, y.rep) > 0;
|
||||
return Fix::compare(x.rep, y.rep) > 0;
|
||||
}
|
||||
|
||||
inline int
|
||||
operator >= (const Fix& x, const Fix& y)
|
||||
{
|
||||
return Fix::compare(x.rep, y.rep) >= 0;
|
||||
return Fix::compare(x.rep, y.rep) >= 0;
|
||||
}
|
||||
|
||||
inline Fix&
|
||||
|
@ -415,7 +415,7 @@ operator << (const Fix& x, int y)
|
|||
|
||||
inline Fix
|
||||
operator >> (const Fix& x, int y)
|
||||
{
|
||||
{
|
||||
Fix::Rep* rep = Fix::shift(x.rep, -y); return rep;
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
|
||||
adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
@ -58,8 +58,8 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
// consists of a 16-bit mantissa (sign bit & 15 data bits).
|
||||
//
|
||||
|
||||
class Fix16
|
||||
{
|
||||
class Fix16
|
||||
{
|
||||
friend class Fix32;
|
||||
|
||||
short m;
|
||||
|
@ -102,7 +102,7 @@ class Fix16
|
|||
Fix16& operator -= (const Fix16& f);
|
||||
Fix16& operator *= (const Fix16& );
|
||||
Fix16& operator /= (const Fix16& f);
|
||||
|
||||
|
||||
Fix16& operator <<=(int b);
|
||||
Fix16& operator >>=(int b);
|
||||
|
||||
|
@ -124,15 +124,15 @@ class Fix16
|
|||
Fix16& operator *= (int g);
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Fix32 class: 32-bit Fixed point data type
|
||||
//
|
||||
// consists of a 32-bit mantissa (sign bit & 31 data bits).
|
||||
//
|
||||
|
||||
class Fix32
|
||||
{
|
||||
class Fix32
|
||||
{
|
||||
friend class Fix16;
|
||||
|
||||
_G_int32_t m;
|
||||
|
@ -241,141 +241,141 @@ extern void
|
|||
inline Fix16::~Fix16() {}
|
||||
|
||||
inline short Fix16::round(double d)
|
||||
{
|
||||
return short( (d >= 0)? d + 0.5 : d - 0.5);
|
||||
{
|
||||
return short( (d >= 0)? d + 0.5 : d - 0.5);
|
||||
}
|
||||
|
||||
inline Fix16::Fix16(short i)
|
||||
{
|
||||
m = i;
|
||||
inline Fix16::Fix16(short i)
|
||||
{
|
||||
m = i;
|
||||
}
|
||||
|
||||
inline Fix16::Fix16(int i)
|
||||
{
|
||||
m = i;
|
||||
inline Fix16::Fix16(int i)
|
||||
{
|
||||
m = i;
|
||||
}
|
||||
|
||||
inline Fix16::operator double() const
|
||||
{
|
||||
return Fix16_div * m;
|
||||
inline Fix16::operator double() const
|
||||
{
|
||||
return Fix16_div * m;
|
||||
}
|
||||
|
||||
inline Fix16::Fix16()
|
||||
{
|
||||
m = 0;
|
||||
inline Fix16::Fix16()
|
||||
{
|
||||
m = 0;
|
||||
}
|
||||
|
||||
inline Fix16::Fix16(const Fix16& f)
|
||||
{
|
||||
m = f.m;
|
||||
inline Fix16::Fix16(const Fix16& f)
|
||||
{
|
||||
m = f.m;
|
||||
}
|
||||
|
||||
inline Fix16::Fix16(double d)
|
||||
inline Fix16::Fix16(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
}
|
||||
|
||||
|
||||
inline Fix16& Fix16::operator=(const Fix16& f)
|
||||
{
|
||||
m = f.m;
|
||||
return *this;
|
||||
inline Fix16& Fix16::operator=(const Fix16& f)
|
||||
{
|
||||
m = f.m;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix16& Fix16::operator=(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
return *this;
|
||||
inline Fix16& Fix16::operator=(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline Fix32::Fix32()
|
||||
{
|
||||
inline Fix32::Fix32()
|
||||
{
|
||||
m = 0;
|
||||
}
|
||||
|
||||
inline Fix32::Fix32(_G_int32_t i)
|
||||
{
|
||||
inline Fix32::Fix32(_G_int32_t i)
|
||||
{
|
||||
m = i;
|
||||
}
|
||||
|
||||
inline Fix32:: operator double() const
|
||||
{
|
||||
inline Fix32:: operator double() const
|
||||
{
|
||||
return Fix32_div * m;
|
||||
}
|
||||
|
||||
|
||||
inline Fix32::Fix32(const Fix32& f)
|
||||
{
|
||||
inline Fix32::Fix32(const Fix32& f)
|
||||
{
|
||||
m = f.m;
|
||||
}
|
||||
|
||||
inline Fix32::Fix32(const Fix16& f)
|
||||
{
|
||||
inline Fix32::Fix32(const Fix16& f)
|
||||
{
|
||||
m = _G_int32_t(f.m) << 16;
|
||||
}
|
||||
|
||||
inline Fix32::Fix32(double d)
|
||||
{
|
||||
inline Fix32::Fix32(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
}
|
||||
|
||||
inline Fix16::Fix16(const Fix32& f)
|
||||
{
|
||||
m = f.m >> 16;
|
||||
inline Fix16::Fix16(const Fix32& f)
|
||||
{
|
||||
m = f.m >> 16;
|
||||
}
|
||||
|
||||
|
||||
inline Fix16& Fix16::operator=(const Fix32& f)
|
||||
{
|
||||
m = f.m >> 16;
|
||||
return *this;
|
||||
{
|
||||
m = f.m >> 16;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator=(const Fix32& f)
|
||||
{
|
||||
inline Fix32& Fix32::operator=(const Fix32& f)
|
||||
{
|
||||
m = f.m;
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator=(const Fix16& f)
|
||||
{
|
||||
inline Fix32& Fix32::operator=(const Fix16& f)
|
||||
{
|
||||
m = _G_int32_t(f.m) << 16;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator=(double d)
|
||||
{
|
||||
inline Fix32& Fix32::operator=(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline short& mantissa(Fix16& f)
|
||||
{
|
||||
return f.m;
|
||||
inline short& mantissa(Fix16& f)
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline const short& mantissa(const Fix16& f)
|
||||
{
|
||||
return f.m;
|
||||
inline const short& mantissa(const Fix16& f)
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline double value(const Fix16& f)
|
||||
{
|
||||
return double(f);
|
||||
inline double value(const Fix16& f)
|
||||
{
|
||||
return double(f);
|
||||
}
|
||||
|
||||
inline Fix16 Fix16::operator+() const
|
||||
{
|
||||
return m;
|
||||
inline Fix16 Fix16::operator+() const
|
||||
{
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Fix16 Fix16::operator-() const
|
||||
{
|
||||
return -m;
|
||||
inline Fix16 Fix16::operator-() const
|
||||
{
|
||||
return -m;
|
||||
}
|
||||
|
||||
inline Fix16 operator+(const Fix16& f, const Fix16& g)
|
||||
inline Fix16 operator+(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
short sum = f.m + g.m;
|
||||
if ( (f.m ^ sum) & (g.m ^ sum) & Fix16_msb )
|
||||
|
@ -383,7 +383,7 @@ inline Fix16 operator+(const Fix16& f, const Fix16& g)
|
|||
return sum;
|
||||
}
|
||||
|
||||
inline Fix16 operator-(const Fix16& f, const Fix16& g)
|
||||
inline Fix16 operator-(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
short sum = f.m - g.m;
|
||||
if ( (f.m ^ sum) & (-g.m ^ sum) & Fix16_msb )
|
||||
|
@ -392,90 +392,90 @@ inline Fix16 operator-(const Fix16& f, const Fix16& g)
|
|||
}
|
||||
|
||||
inline Fix32 operator*(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
return Fix32( _G_int32_t( _G_int32_t(f.m) * _G_int32_t(g.m) << 1));
|
||||
{
|
||||
return Fix32( _G_int32_t( _G_int32_t(f.m) * _G_int32_t(g.m) << 1));
|
||||
}
|
||||
|
||||
inline Fix16 operator<<(const Fix16& a, int b)
|
||||
{
|
||||
return a.m << b;
|
||||
inline Fix16 operator<<(const Fix16& a, int b)
|
||||
{
|
||||
return a.m << b;
|
||||
}
|
||||
|
||||
inline Fix16 operator>>(const Fix16& a, int b)
|
||||
{
|
||||
return a.m >> b;
|
||||
inline Fix16 operator>>(const Fix16& a, int b)
|
||||
{
|
||||
return a.m >> b;
|
||||
}
|
||||
|
||||
inline Fix16& Fix16:: operator+=(const Fix16& f)
|
||||
{
|
||||
return *this = *this + f;
|
||||
{
|
||||
return *this = *this + f;
|
||||
}
|
||||
|
||||
inline Fix16& Fix16:: operator-=(const Fix16& f)
|
||||
{
|
||||
return *this = *this - f;
|
||||
inline Fix16& Fix16:: operator-=(const Fix16& f)
|
||||
{
|
||||
return *this = *this - f;
|
||||
}
|
||||
|
||||
inline Fix16& Fix16::operator*=(const Fix16& f)
|
||||
{
|
||||
return *this = *this * f;
|
||||
inline Fix16& Fix16::operator*=(const Fix16& f)
|
||||
{
|
||||
return *this = *this * f;
|
||||
}
|
||||
|
||||
inline Fix16& Fix16:: operator/=(const Fix16& f)
|
||||
{
|
||||
return *this = *this / f;
|
||||
inline Fix16& Fix16:: operator/=(const Fix16& f)
|
||||
{
|
||||
return *this = *this / f;
|
||||
}
|
||||
|
||||
inline Fix16& Fix16:: operator<<=(int b)
|
||||
{
|
||||
inline Fix16& Fix16:: operator<<=(int b)
|
||||
{
|
||||
return *this = *this << b;
|
||||
}
|
||||
|
||||
inline Fix16& Fix16:: operator>>=(int b)
|
||||
{
|
||||
inline Fix16& Fix16:: operator>>=(int b)
|
||||
{
|
||||
return *this = *this >> b;
|
||||
}
|
||||
|
||||
inline int operator==(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
inline int operator==(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
return f.m == g.m;
|
||||
}
|
||||
|
||||
inline int operator!=(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
inline int operator!=(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
return f.m != g.m;
|
||||
}
|
||||
|
||||
inline int operator>=(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
inline int operator>=(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
return f.m >= g.m;
|
||||
}
|
||||
|
||||
inline int operator<=(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
inline int operator<=(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
return f.m <= g.m;
|
||||
}
|
||||
|
||||
inline int operator>(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
inline int operator>(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
return f.m > g.m;
|
||||
}
|
||||
|
||||
inline int operator<(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
inline int operator<(const Fix16& f, const Fix16& g)
|
||||
{
|
||||
return f.m < g.m;
|
||||
}
|
||||
|
||||
inline istream& operator>>(istream& s, Fix16& f)
|
||||
{
|
||||
{
|
||||
double d;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
}
|
||||
|
||||
inline ostream& operator<<(ostream& s, const Fix16& f)
|
||||
{
|
||||
{
|
||||
return s << double(f);
|
||||
}
|
||||
|
||||
|
@ -499,36 +499,36 @@ inline Fix16& Fix16::operator*=(int g)
|
|||
inline Fix32::~Fix32() {}
|
||||
|
||||
inline _G_int32_t Fix32::round(double d)
|
||||
{
|
||||
{
|
||||
return _G_int32_t( (d >= 0)? d + 0.5 : d - 0.5);
|
||||
}
|
||||
|
||||
inline _G_int32_t& mantissa(Fix32& f)
|
||||
{
|
||||
inline _G_int32_t& mantissa(Fix32& f)
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline const _G_int32_t& mantissa(const Fix32& f)
|
||||
{
|
||||
inline const _G_int32_t& mantissa(const Fix32& f)
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline double value(const Fix32& f)
|
||||
{
|
||||
inline double value(const Fix32& f)
|
||||
{
|
||||
return double(f);
|
||||
}
|
||||
|
||||
inline Fix32 Fix32::operator+() const
|
||||
{
|
||||
{
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Fix32 Fix32::operator-() const
|
||||
{
|
||||
inline Fix32 Fix32::operator-() const
|
||||
{
|
||||
return -m;
|
||||
}
|
||||
|
||||
inline Fix32 operator+(const Fix32& f, const Fix32& g)
|
||||
inline Fix32 operator+(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
_G_int32_t sum = f.m + g.m;
|
||||
if ( (f.m ^ sum) & (g.m ^ sum) & Fix32_msb )
|
||||
|
@ -536,7 +536,7 @@ inline Fix32 operator+(const Fix32& f, const Fix32& g)
|
|||
return sum;
|
||||
}
|
||||
|
||||
inline Fix32 operator-(const Fix32& f, const Fix32& g)
|
||||
inline Fix32 operator-(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
_G_int32_t sum = f.m - g.m;
|
||||
if ( (f.m ^ sum) & (-g.m ^ sum) & Fix32_msb )
|
||||
|
@ -544,87 +544,87 @@ inline Fix32 operator-(const Fix32& f, const Fix32& g)
|
|||
return sum;
|
||||
}
|
||||
|
||||
inline Fix32 operator<<(const Fix32& a, int b)
|
||||
{
|
||||
inline Fix32 operator<<(const Fix32& a, int b)
|
||||
{
|
||||
return a.m << b;
|
||||
}
|
||||
|
||||
inline Fix32 operator>>(const Fix32& a, int b)
|
||||
{
|
||||
inline Fix32 operator>>(const Fix32& a, int b)
|
||||
{
|
||||
return a.m >> b;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator+=(const Fix32& f)
|
||||
{
|
||||
inline Fix32& Fix32::operator+=(const Fix32& f)
|
||||
{
|
||||
return *this = *this + f;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator-=(const Fix32& f)
|
||||
{
|
||||
inline Fix32& Fix32::operator-=(const Fix32& f)
|
||||
{
|
||||
return *this = *this - f;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator*=(const Fix32& f)
|
||||
{
|
||||
inline Fix32& Fix32::operator*=(const Fix32& f)
|
||||
{
|
||||
return *this = *this * f;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator/=(const Fix32& f)
|
||||
{
|
||||
inline Fix32& Fix32::operator/=(const Fix32& f)
|
||||
{
|
||||
return *this = *this / f;
|
||||
}
|
||||
|
||||
|
||||
inline Fix32& Fix32::operator<<=(int b)
|
||||
{
|
||||
inline Fix32& Fix32::operator<<=(int b)
|
||||
{
|
||||
return *this = *this << b;
|
||||
}
|
||||
|
||||
inline Fix32& Fix32::operator>>=(int b)
|
||||
{
|
||||
inline Fix32& Fix32::operator>>=(int b)
|
||||
{
|
||||
return *this = *this >> b;
|
||||
}
|
||||
|
||||
inline int operator==(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
inline int operator==(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
return f.m == g.m;
|
||||
}
|
||||
|
||||
inline int operator!=(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
inline int operator!=(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
return f.m != g.m;
|
||||
}
|
||||
|
||||
inline int operator>=(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
inline int operator>=(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
return f.m >= g.m;
|
||||
}
|
||||
|
||||
inline int operator<=(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
inline int operator<=(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
return f.m <= g.m;
|
||||
}
|
||||
|
||||
inline int operator>(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
inline int operator>(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
return f.m > g.m;
|
||||
}
|
||||
|
||||
inline int operator<(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
inline int operator<(const Fix32& f, const Fix32& g)
|
||||
{
|
||||
return f.m < g.m;
|
||||
}
|
||||
|
||||
inline istream& operator>>(istream& s, Fix32& f)
|
||||
{
|
||||
{
|
||||
double d;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
}
|
||||
|
||||
inline ostream& operator<<(ostream& s, const Fix32& f)
|
||||
{
|
||||
{
|
||||
return s << double(f);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
|
||||
adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
@ -26,7 +26,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#include <stream.h>
|
||||
#include <std.h>
|
||||
|
||||
// extra type definitions
|
||||
// extra type definitions
|
||||
|
||||
typedef struct {
|
||||
_G_int32_t u;
|
||||
|
@ -37,14 +37,14 @@ typedef struct {
|
|||
|
||||
static const int
|
||||
Fix24_shift = 31;
|
||||
|
||||
|
||||
static const double
|
||||
Fix24_fs = 2147483648., // 2^Fix24_shift
|
||||
Fix24_mult = Fix24_fs,
|
||||
Fix24_div = 1./Fix24_fs,
|
||||
Fix24_max = 1. - .5/Fix24_fs,
|
||||
Fix24_min = -1.;
|
||||
|
||||
|
||||
static const _G_uint32_t
|
||||
Fix24_msb = 0x80000000L,
|
||||
Fix24_lsb = 0x00000100L,
|
||||
|
@ -57,21 +57,21 @@ static const double
|
|||
Fix48_min = -1.,
|
||||
Fix48_div_u = 1./Fix24_fs,
|
||||
Fix48_div_l = 1./Fix48_fs;
|
||||
|
||||
|
||||
static const twolongs
|
||||
Fix48_msb = { 0x80000000L, 0L },
|
||||
Fix48_lsb = { 0L, 0x00000100L },
|
||||
Fix48_m_max = { 0x7fffff00L, 0xffffff00L },
|
||||
Fix48_m_min = { 0x80000000L, 0L };
|
||||
|
||||
|
||||
//
|
||||
// Fix24 class: 24-bit Fixed point data type
|
||||
//
|
||||
// consists of a 24-bit mantissa (sign bit & 23 data bits).
|
||||
//
|
||||
|
||||
class Fix24
|
||||
{
|
||||
class Fix24
|
||||
{
|
||||
friend class Fix48;
|
||||
|
||||
_G_int32_t m;
|
||||
|
@ -133,15 +133,15 @@ class Fix24
|
|||
void range_error(_G_int32_t&) const;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Fix48 class: 48-bit Fixed point data type
|
||||
//
|
||||
// consists of a 48-bit mantissa (sign bit & 47 data bits).
|
||||
//
|
||||
|
||||
class Fix48
|
||||
{
|
||||
class Fix48
|
||||
{
|
||||
friend class Fix24;
|
||||
|
||||
twolongs m;
|
||||
|
@ -242,85 +242,85 @@ extern void
|
|||
|
||||
inline Fix24::~Fix24() {}
|
||||
|
||||
inline Fix24::Fix24(long i)
|
||||
{
|
||||
m = i;
|
||||
inline Fix24::Fix24(long i)
|
||||
{
|
||||
m = i;
|
||||
}
|
||||
|
||||
inline Fix24::Fix24(int i)
|
||||
{
|
||||
m = i;
|
||||
inline Fix24::Fix24(int i)
|
||||
{
|
||||
m = i;
|
||||
}
|
||||
|
||||
inline Fix24::operator double() const
|
||||
{
|
||||
return Fix24_div * m;
|
||||
{
|
||||
return Fix24_div * m;
|
||||
}
|
||||
|
||||
inline Fix24::Fix24()
|
||||
{
|
||||
m = 0;
|
||||
inline Fix24::Fix24()
|
||||
{
|
||||
m = 0;
|
||||
}
|
||||
|
||||
inline Fix24::Fix24(const Fix24& f)
|
||||
{
|
||||
m = f.m;
|
||||
inline Fix24::Fix24(const Fix24& f)
|
||||
{
|
||||
m = f.m;
|
||||
}
|
||||
|
||||
inline Fix24::Fix24(double d)
|
||||
inline Fix24::Fix24(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
}
|
||||
|
||||
inline Fix24::Fix24(const Fix48& f)
|
||||
{
|
||||
inline Fix24::Fix24(const Fix48& f)
|
||||
{
|
||||
m = f.m.u;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24::operator=(const Fix24& f)
|
||||
{
|
||||
m = f.m;
|
||||
return *this;
|
||||
inline Fix24& Fix24::operator=(const Fix24& f)
|
||||
{
|
||||
m = f.m;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24::operator=(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
return *this;
|
||||
inline Fix24& Fix24::operator=(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24::operator=(const Fix48& f)
|
||||
{
|
||||
{
|
||||
m = f.m.u;
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline _G_int32_t& mantissa(Fix24& f)
|
||||
{
|
||||
return f.m;
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline const _G_int32_t& mantissa(const Fix24& f)
|
||||
{
|
||||
return f.m;
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline double value(const Fix24& f)
|
||||
{
|
||||
return double(f);
|
||||
{
|
||||
return double(f);
|
||||
}
|
||||
|
||||
inline Fix24 Fix24::operator+() const
|
||||
{
|
||||
return m;
|
||||
inline Fix24 Fix24::operator+() const
|
||||
{
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Fix24 Fix24::operator-() const
|
||||
{
|
||||
return -m;
|
||||
{
|
||||
return -m;
|
||||
}
|
||||
|
||||
inline Fix24 operator+(const Fix24& f, const Fix24& g)
|
||||
inline Fix24 operator+(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
_G_int32_t sum = f.m + g.m;
|
||||
if ( (f.m ^ sum) & (g.m ^ sum) & Fix24_msb )
|
||||
|
@ -328,7 +328,7 @@ inline Fix24 operator+(const Fix24& f, const Fix24& g)
|
|||
return sum;
|
||||
}
|
||||
|
||||
inline Fix24 operator-(const Fix24& f, const Fix24& g)
|
||||
inline Fix24 operator-(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
_G_int32_t sum = f.m - g.m;
|
||||
if ( (f.m ^ sum) & (-g.m ^ sum) & Fix24_msb )
|
||||
|
@ -336,23 +336,23 @@ inline Fix24 operator-(const Fix24& f, const Fix24& g)
|
|||
return sum;
|
||||
}
|
||||
|
||||
inline Fix24 operator*(const Fix24& a, int b)
|
||||
{
|
||||
return a.m * b;
|
||||
inline Fix24 operator*(const Fix24& a, int b)
|
||||
{
|
||||
return a.m * b;
|
||||
}
|
||||
|
||||
inline Fix24 operator*(int b, const Fix24& a)
|
||||
{
|
||||
return a * b;
|
||||
inline Fix24 operator*(int b, const Fix24& a)
|
||||
{
|
||||
return a * b;
|
||||
}
|
||||
|
||||
inline Fix24 operator<<(const Fix24& a, int b)
|
||||
{
|
||||
return a.m << b;
|
||||
inline Fix24 operator<<(const Fix24& a, int b)
|
||||
{
|
||||
return a.m << b;
|
||||
}
|
||||
|
||||
inline Fix24 operator>>(const Fix24& a, int b)
|
||||
{
|
||||
inline Fix24 operator>>(const Fix24& a, int b)
|
||||
{
|
||||
return (a.m >> b) & ~0xff;
|
||||
}
|
||||
|
||||
|
@ -361,236 +361,236 @@ inline Fix24& Fix24:: operator+=(const Fix24& f)
|
|||
return *this = *this + f;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24:: operator-=(const Fix24& f)
|
||||
{
|
||||
return *this = *this - f;
|
||||
inline Fix24& Fix24:: operator-=(const Fix24& f)
|
||||
{
|
||||
return *this = *this - f;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24::operator*=(const Fix24& f)
|
||||
{
|
||||
return *this = *this * f;
|
||||
inline Fix24& Fix24::operator*=(const Fix24& f)
|
||||
{
|
||||
return *this = *this * f;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24:: operator/=(const Fix24& f)
|
||||
{
|
||||
return *this = *this / f;
|
||||
inline Fix24& Fix24:: operator/=(const Fix24& f)
|
||||
{
|
||||
return *this = *this / f;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24:: operator<<=(int b)
|
||||
{
|
||||
inline Fix24& Fix24:: operator<<=(int b)
|
||||
{
|
||||
return *this = *this << b;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24:: operator>>=(int b)
|
||||
{
|
||||
inline Fix24& Fix24:: operator>>=(int b)
|
||||
{
|
||||
return *this = *this >> b;
|
||||
}
|
||||
|
||||
inline Fix24& Fix24::operator*=(int b)
|
||||
{
|
||||
return *this = *this * b;
|
||||
{
|
||||
return *this = *this * b;
|
||||
}
|
||||
|
||||
inline int operator==(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
inline int operator==(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
return f.m == g.m;
|
||||
}
|
||||
|
||||
inline int operator!=(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
inline int operator!=(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
return f.m != g.m;
|
||||
}
|
||||
|
||||
inline int operator>=(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
inline int operator>=(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
return f.m >= g.m;
|
||||
}
|
||||
|
||||
inline int operator<=(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
inline int operator<=(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
return f.m <= g.m;
|
||||
}
|
||||
|
||||
inline int operator>(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
inline int operator>(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
return f.m > g.m;
|
||||
}
|
||||
|
||||
inline int operator<(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
inline int operator<(const Fix24& f, const Fix24& g)
|
||||
{
|
||||
return f.m < g.m;
|
||||
}
|
||||
|
||||
inline istream& operator>>(istream& s, Fix24& f)
|
||||
{
|
||||
{
|
||||
double d;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
}
|
||||
|
||||
inline ostream& operator<<(ostream& s, const Fix24& f)
|
||||
{
|
||||
{
|
||||
return s << double(f);
|
||||
}
|
||||
|
||||
inline Fix48::~Fix48() {}
|
||||
|
||||
inline Fix48::Fix48(twolongs i)
|
||||
{
|
||||
inline Fix48::Fix48(twolongs i)
|
||||
{
|
||||
m = i;
|
||||
}
|
||||
|
||||
inline Fix48:: operator double() const
|
||||
{
|
||||
{
|
||||
/*
|
||||
* Note: can't simply do Fix48_div_u * m.u + Fix48_div_l * m.l, because
|
||||
* m.u is signed and m.l is unsigned.
|
||||
*/
|
||||
return (m.u >= 0)? Fix48_div_u * m.u + Fix48_div_l * m.l :
|
||||
(Fix48_div_u * ((_G_uint32_t)(m.u & 0xffffff00))
|
||||
(Fix48_div_u * ((_G_uint32_t)(m.u & 0xffffff00))
|
||||
+ Fix48_div_l * m.l) - 2;
|
||||
}
|
||||
|
||||
inline Fix48::Fix48()
|
||||
{
|
||||
inline Fix48::Fix48()
|
||||
{
|
||||
m.u = 0;
|
||||
m.l = 0;
|
||||
}
|
||||
|
||||
inline Fix48::Fix48(const Fix48& f)
|
||||
{
|
||||
inline Fix48::Fix48(const Fix48& f)
|
||||
{
|
||||
m = f.m;
|
||||
}
|
||||
|
||||
inline Fix48::Fix48(const Fix24& f)
|
||||
{
|
||||
inline Fix48::Fix48(const Fix24& f)
|
||||
{
|
||||
m.u = f.m;
|
||||
m.l = 0;
|
||||
}
|
||||
|
||||
inline Fix48::Fix48(double d)
|
||||
{
|
||||
inline Fix48::Fix48(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator=(const Fix48& f)
|
||||
{
|
||||
inline Fix48& Fix48::operator=(const Fix48& f)
|
||||
{
|
||||
m = f.m;
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator=(const Fix24& f)
|
||||
{
|
||||
inline Fix48& Fix48::operator=(const Fix24& f)
|
||||
{
|
||||
m.u = f.m;
|
||||
m.l = 0;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator=(double d)
|
||||
{
|
||||
inline Fix48& Fix48::operator=(double d)
|
||||
{
|
||||
m = assign(d);
|
||||
return *this;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline twolongs& mantissa(Fix48& f)
|
||||
{
|
||||
inline twolongs& mantissa(Fix48& f)
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline const twolongs& mantissa(const Fix48& f)
|
||||
{
|
||||
inline const twolongs& mantissa(const Fix48& f)
|
||||
{
|
||||
return f.m;
|
||||
}
|
||||
|
||||
inline double value(const Fix48& f)
|
||||
{
|
||||
{
|
||||
return double(f);
|
||||
}
|
||||
|
||||
inline Fix48 Fix48::operator+() const
|
||||
{
|
||||
inline Fix48 Fix48::operator+() const
|
||||
{
|
||||
return m;
|
||||
}
|
||||
|
||||
inline Fix48 Fix48::operator-() const
|
||||
{
|
||||
{
|
||||
twolongs n;
|
||||
n.l = -m.l;
|
||||
n.u = ~m.u + ((n.l ^ m.l) & Fix24_msb ? 0 : Fix24_lsb);
|
||||
return Fix48(n);
|
||||
}
|
||||
|
||||
inline Fix48 operator*(int b, const Fix48& a)
|
||||
{
|
||||
return a * b;
|
||||
inline Fix48 operator*(int b, const Fix48& a)
|
||||
{
|
||||
return a * b;
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator+=(const Fix48& f)
|
||||
{
|
||||
inline Fix48& Fix48::operator+=(const Fix48& f)
|
||||
{
|
||||
return *this = *this + f;
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator-=(const Fix48& f)
|
||||
{
|
||||
inline Fix48& Fix48::operator-=(const Fix48& f)
|
||||
{
|
||||
return *this = *this - f;
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator*=(int b)
|
||||
{
|
||||
inline Fix48& Fix48::operator*=(int b)
|
||||
{
|
||||
return *this = *this * b;
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator<<=(int b)
|
||||
{
|
||||
inline Fix48& Fix48::operator<<=(int b)
|
||||
{
|
||||
return *this = *this << b;
|
||||
}
|
||||
|
||||
inline Fix48& Fix48::operator>>=(int b)
|
||||
{
|
||||
inline Fix48& Fix48::operator>>=(int b)
|
||||
{
|
||||
return *this = *this >> b;
|
||||
}
|
||||
|
||||
inline int operator==(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
inline int operator==(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
return f.m.u == g.m.u && f.m.l == g.m.l;
|
||||
}
|
||||
|
||||
inline int operator!=(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
inline int operator!=(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
return f.m.u != g.m.u || f.m.l != g.m.l;
|
||||
}
|
||||
|
||||
inline int operator>=(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
inline int operator>=(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
return f.m.u >= g.m.u || (f.m.u == g.m.u && f.m.l >= g.m.l);
|
||||
}
|
||||
|
||||
inline int operator<=(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
inline int operator<=(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
return f.m.u <= g.m.u || (f.m.u == g.m.u && f.m.l <= g.m.l);
|
||||
}
|
||||
|
||||
inline int operator>(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
inline int operator>(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
return f.m.u > g.m.u || (f.m.u == g.m.u && f.m.l > g.m.l);
|
||||
}
|
||||
|
||||
inline int operator<(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
inline int operator<(const Fix48& f, const Fix48& g)
|
||||
{
|
||||
return f.m.u < g.m.u || (f.m.u == g.m.u && f.m.l < g.m.l);
|
||||
}
|
||||
|
||||
inline istream& operator>>(istream& s, Fix48& f)
|
||||
{
|
||||
{
|
||||
double d;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
s >> d;
|
||||
f = d;
|
||||
return s;
|
||||
}
|
||||
|
||||
inline ostream& operator<<(ostream& s, const Fix48& f)
|
||||
{
|
||||
{
|
||||
return s << double(f);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -19,7 +19,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
#define _Geometric_h
|
||||
#define _Geometric_h
|
||||
|
||||
#include <Random.h>
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* Getopt for GNU.
|
||||
/* Getopt for GNU.
|
||||
Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
|
||||
(Modified by Douglas C. Schmidt for use with GNU G++.)
|
||||
|
||||
|
@ -45,51 +45,51 @@ class GetOpt
|
|||
/* The next char to be scanned in the option-element
|
||||
in which the last option character we returned was found.
|
||||
This allows us to pick up the scan where we left off.
|
||||
|
||||
|
||||
If this is zero, or a null string, it means resume the scan
|
||||
by advancing to the next ARGV-element. */
|
||||
|
||||
|
||||
static char *nextchar;
|
||||
|
||||
|
||||
|
||||
|
||||
/* Describe how to deal with options that follow non-option ARGV-elements.
|
||||
|
||||
|
||||
UNSPECIFIED means the caller did not specify anything;
|
||||
the default is then REQUIRE_ORDER if the environment variable
|
||||
_OPTIONS_FIRST is defined, PERMUTE otherwise.
|
||||
|
||||
|
||||
REQUIRE_ORDER means don't recognize them as options.
|
||||
Stop option processing when the first non-option is seen.
|
||||
This is what Unix does.
|
||||
|
||||
|
||||
PERMUTE is the default. We permute the contents of `argv' as we scan,
|
||||
so that eventually all the options are at the end. This allows options
|
||||
to be given in any order, even with programs that were not written to
|
||||
expect this.
|
||||
|
||||
|
||||
RETURN_IN_ORDER is an option available to programs that were written
|
||||
to expect options and other ARGV-elements in any order and that care about
|
||||
the ordering of the two. We describe each non-option ARGV-element
|
||||
as if it were the argument of an option with character code zero.
|
||||
Using `-' as the first character of the list of option characters
|
||||
requests this mode of operation.
|
||||
|
||||
|
||||
The special argument `--' forces an end of option-scanning regardless
|
||||
of the value of `ordering'. In the case of RETURN_IN_ORDER, only
|
||||
`--' can cause `getopt' to return EOF with `optind' != ARGC. */
|
||||
|
||||
|
||||
enum OrderingEnum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER };
|
||||
OrderingEnum ordering;
|
||||
|
||||
/* Handle permutation of arguments. */
|
||||
|
||||
|
||||
/* Describe the part of ARGV that contains non-options that have
|
||||
been skipped. `first_nonopt' is the index in ARGV of the first of them;
|
||||
`last_nonopt' is the index after the last of them. */
|
||||
|
||||
|
||||
static int first_nonopt;
|
||||
static int last_nonopt;
|
||||
|
||||
|
||||
void exchange (char **argv);
|
||||
public:
|
||||
/* For communication from `getopt' to the caller.
|
||||
|
@ -97,31 +97,31 @@ class GetOpt
|
|||
the argument value is returned here.
|
||||
Also, when `ordering' is RETURN_IN_ORDER,
|
||||
each non-option ARGV-element is returned here. */
|
||||
|
||||
|
||||
char *optarg;
|
||||
|
||||
|
||||
/* Index in ARGV of the next element to be scanned.
|
||||
This is used for communication to and from the caller
|
||||
and for communication between successive calls to `getopt'.
|
||||
On entry to `getopt', zero means this is the first call; initialize.
|
||||
|
||||
|
||||
When `getopt' returns EOF, this is the index of the first of the
|
||||
non-option elements that the caller should itself scan.
|
||||
|
||||
|
||||
Otherwise, `optind' communicates from one call to the next
|
||||
how much of ARGV has been scanned so far. */
|
||||
|
||||
|
||||
int optind;
|
||||
|
||||
/* Callers store zero here to inhibit the error message
|
||||
for unrecognized options. */
|
||||
|
||||
|
||||
int opterr;
|
||||
|
||||
|
||||
int nargc;
|
||||
char **nargv;
|
||||
const char *noptstring;
|
||||
|
||||
|
||||
GetOpt (int argc, char **argv, const char *optstring);
|
||||
int operator () (void);
|
||||
};
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -19,7 +19,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
#define _HyperGeometric_h
|
||||
#define _HyperGeometric_h
|
||||
|
||||
#include <Random.h>
|
||||
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -29,7 +29,7 @@ struct IntRep // internal Integer representations
|
|||
{
|
||||
unsigned short len; // current length
|
||||
unsigned short sz; // allocated space (0 means static).
|
||||
short sgn; // 1 means >= 0; 0 means < 0
|
||||
short sgn; // 1 means >= 0; 0 means < 0
|
||||
unsigned short s[1]; // represented as ushort array starting here
|
||||
};
|
||||
|
||||
|
@ -67,7 +67,7 @@ extern int ucompare(const IntRep*, const IntRep*);
|
|||
extern int ucompare(const IntRep*, long);
|
||||
extern char* Itoa(const IntRep* x, int base = 10, int width = 0);
|
||||
extern char* cvtItoa(const IntRep* x, char* fmt, int& fmtlen, int base,
|
||||
int showbase, int width, int align_right,
|
||||
int showbase, int width, int align_right,
|
||||
char fillchar, char Xcase, int showpos);
|
||||
extern IntRep* atoIntRep(const char* s, int base = 10);
|
||||
extern long Itolong(const IntRep*);
|
||||
|
@ -152,14 +152,14 @@ class Integer
|
|||
friend void negate(const Integer& x, Integer& dest);
|
||||
friend void complement(const Integer& x, Integer& dest);
|
||||
|
||||
friend int compare(const Integer&, const Integer&);
|
||||
friend int ucompare(const Integer&, const Integer&);
|
||||
friend int compare(const Integer&, const Integer&);
|
||||
friend int ucompare(const Integer&, const Integer&);
|
||||
friend void add(const Integer& x, const Integer& y, Integer& dest);
|
||||
friend void sub(const Integer& x, const Integer& y, Integer& dest);
|
||||
friend void mul(const Integer& x, const Integer& y, Integer& dest);
|
||||
friend void div(const Integer& x, const Integer& y, Integer& dest);
|
||||
friend void mod(const Integer& x, const Integer& y, Integer& dest);
|
||||
friend void divide(const Integer& x, const Integer& y,
|
||||
friend void divide(const Integer& x, const Integer& y,
|
||||
Integer& q, Integer& r);
|
||||
friend void and(const Integer& x, const Integer& y, Integer& dest);
|
||||
friend void or(const Integer& x, const Integer& y, Integer& dest);
|
||||
|
@ -168,8 +168,8 @@ class Integer
|
|||
friend void rshift(const Integer& x, const Integer& y, Integer& dest);
|
||||
friend void pow(const Integer& x, const Integer& y, Integer& dest);
|
||||
|
||||
friend int compare(const Integer&, long);
|
||||
friend int ucompare(const Integer&, long);
|
||||
friend int compare(const Integer&, long);
|
||||
friend int ucompare(const Integer&, long);
|
||||
friend void add(const Integer& x, long y, Integer& dest);
|
||||
friend void sub(const Integer& x, long y, Integer& dest);
|
||||
friend void mul(const Integer& x, long y, Integer& dest);
|
||||
|
@ -183,8 +183,8 @@ class Integer
|
|||
friend void rshift(const Integer& x, long y, Integer& dest);
|
||||
friend void pow(const Integer& x, long y, Integer& dest);
|
||||
|
||||
friend int compare(long, const Integer&);
|
||||
friend int ucompare(long, const Integer&);
|
||||
friend int compare(long, const Integer&);
|
||||
friend int ucompare(long, const Integer&);
|
||||
friend void add(long x, const Integer& y, Integer& dest);
|
||||
friend void sub(long x, const Integer& y, Integer& dest);
|
||||
friend void mul(long x, const Integer& y, Integer& dest);
|
||||
|
@ -203,7 +203,7 @@ class Integer
|
|||
friend char* Itoa(const Integer& x, int base = 10, int width = 0);
|
||||
friend Integer atoI(const char* s, int base = 10);
|
||||
void printon(ostream& s, int base = 10, int width = 0) const;
|
||||
|
||||
|
||||
friend istream& operator >> (istream& s, Integer& y);
|
||||
friend ostream& operator << (ostream& s, const Integer& y);
|
||||
|
||||
|
@ -211,7 +211,7 @@ class Integer
|
|||
|
||||
int initialized() const;
|
||||
void error(const char* msg) const;
|
||||
int OK() const;
|
||||
int OK() const;
|
||||
};
|
||||
|
||||
|
||||
|
@ -263,7 +263,7 @@ class Integer
|
|||
|
||||
Integer pow(const Integer& x, const Integer& y);
|
||||
Integer pow(const Integer& x, long y);
|
||||
Integer Ipow(long x, long y); // x to the y as Integer
|
||||
Integer Ipow(long x, long y); // x to the y as Integer
|
||||
|
||||
|
||||
extern char* dec(const Integer& x, int width = 0);
|
||||
|
@ -498,62 +498,62 @@ inline void xor(long x, const Integer& y, Integer& dest)
|
|||
|
||||
inline int operator == (const Integer& x, const Integer& y)
|
||||
{
|
||||
return compare(x, y) == 0;
|
||||
return compare(x, y) == 0;
|
||||
}
|
||||
|
||||
inline int operator == (const Integer& x, long y)
|
||||
{
|
||||
return compare(x, y) == 0;
|
||||
return compare(x, y) == 0;
|
||||
}
|
||||
|
||||
inline int operator != (const Integer& x, const Integer& y)
|
||||
{
|
||||
return compare(x, y) != 0;
|
||||
return compare(x, y) != 0;
|
||||
}
|
||||
|
||||
inline int operator != (const Integer& x, long y)
|
||||
{
|
||||
return compare(x, y) != 0;
|
||||
return compare(x, y) != 0;
|
||||
}
|
||||
|
||||
inline int operator < (const Integer& x, const Integer& y)
|
||||
{
|
||||
return compare(x, y) < 0;
|
||||
return compare(x, y) < 0;
|
||||
}
|
||||
|
||||
inline int operator < (const Integer& x, long y)
|
||||
{
|
||||
return compare(x, y) < 0;
|
||||
return compare(x, y) < 0;
|
||||
}
|
||||
|
||||
inline int operator <= (const Integer& x, const Integer& y)
|
||||
{
|
||||
return compare(x, y) <= 0;
|
||||
return compare(x, y) <= 0;
|
||||
}
|
||||
|
||||
inline int operator <= (const Integer& x, long y)
|
||||
{
|
||||
return compare(x, y) <= 0;
|
||||
return compare(x, y) <= 0;
|
||||
}
|
||||
|
||||
inline int operator > (const Integer& x, const Integer& y)
|
||||
{
|
||||
return compare(x, y) > 0;
|
||||
return compare(x, y) > 0;
|
||||
}
|
||||
|
||||
inline int operator > (const Integer& x, long y)
|
||||
{
|
||||
return compare(x, y) > 0;
|
||||
return compare(x, y) > 0;
|
||||
}
|
||||
|
||||
inline int operator >= (const Integer& x, const Integer& y)
|
||||
{
|
||||
return compare(x, y) >= 0;
|
||||
return compare(x, y) >= 0;
|
||||
}
|
||||
|
||||
inline int operator >= (const Integer& x, long y)
|
||||
{
|
||||
return compare(x, y) >= 0;
|
||||
return compare(x, y) >= 0;
|
||||
}
|
||||
|
||||
|
||||
|
@ -738,12 +738,12 @@ inline char* Itoa(const Integer& y, int base, int width)
|
|||
|
||||
|
||||
|
||||
inline long lg(const Integer& x)
|
||||
inline long lg(const Integer& x)
|
||||
{
|
||||
return lg(x.rep);
|
||||
}
|
||||
|
||||
// constructive operations
|
||||
// constructive operations
|
||||
|
||||
#if defined(__GNUG__) && !defined(_G_NO_NRV)
|
||||
|
||||
|
@ -926,179 +926,179 @@ inline Integer gcd(const Integer& x, const Integer& y) return r
|
|||
|
||||
#else /* NO_NRV */
|
||||
|
||||
inline Integer operator + (const Integer& x, const Integer& y)
|
||||
inline Integer operator + (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; add(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator + (const Integer& x, long y)
|
||||
inline Integer operator + (const Integer& x, long y)
|
||||
{
|
||||
Integer r; add(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator + (long x, const Integer& y)
|
||||
inline Integer operator + (long x, const Integer& y)
|
||||
{
|
||||
Integer r; add(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator - (const Integer& x, const Integer& y)
|
||||
inline Integer operator - (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; sub(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator - (const Integer& x, long y)
|
||||
inline Integer operator - (const Integer& x, long y)
|
||||
{
|
||||
Integer r; sub(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator - (long x, const Integer& y)
|
||||
inline Integer operator - (long x, const Integer& y)
|
||||
{
|
||||
Integer r; sub(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator * (const Integer& x, const Integer& y)
|
||||
inline Integer operator * (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; mul(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator * (const Integer& x, long y)
|
||||
inline Integer operator * (const Integer& x, long y)
|
||||
{
|
||||
Integer r; mul(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator * (long x, const Integer& y)
|
||||
inline Integer operator * (long x, const Integer& y)
|
||||
{
|
||||
Integer r; mul(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer sqr(const Integer& x)
|
||||
inline Integer sqr(const Integer& x)
|
||||
{
|
||||
Integer r; mul(x, x, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator & (const Integer& x, const Integer& y)
|
||||
inline Integer operator & (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; and(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator & (const Integer& x, long y)
|
||||
inline Integer operator & (const Integer& x, long y)
|
||||
{
|
||||
Integer r; and(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator & (long x, const Integer& y)
|
||||
inline Integer operator & (long x, const Integer& y)
|
||||
{
|
||||
Integer r; and(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator | (const Integer& x, const Integer& y)
|
||||
inline Integer operator | (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; or(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator | (const Integer& x, long y)
|
||||
inline Integer operator | (const Integer& x, long y)
|
||||
{
|
||||
Integer r; or(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator | (long x, const Integer& y)
|
||||
inline Integer operator | (long x, const Integer& y)
|
||||
{
|
||||
Integer r; or(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator ^ (const Integer& x, const Integer& y)
|
||||
inline Integer operator ^ (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; xor(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator ^ (const Integer& x, long y)
|
||||
inline Integer operator ^ (const Integer& x, long y)
|
||||
{
|
||||
Integer r; xor(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator ^ (long x, const Integer& y)
|
||||
inline Integer operator ^ (long x, const Integer& y)
|
||||
{
|
||||
Integer r; xor(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator / (const Integer& x, const Integer& y)
|
||||
inline Integer operator / (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; div(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator / (const Integer& x, long y)
|
||||
inline Integer operator / (const Integer& x, long y)
|
||||
{
|
||||
Integer r; div(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator % (const Integer& x, const Integer& y)
|
||||
inline Integer operator % (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; mod(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator % (const Integer& x, long y)
|
||||
inline Integer operator % (const Integer& x, long y)
|
||||
{
|
||||
Integer r; mod(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator << (const Integer& x, const Integer& y)
|
||||
inline Integer operator << (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; lshift(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator << (const Integer& x, long y)
|
||||
inline Integer operator << (const Integer& x, long y)
|
||||
{
|
||||
Integer r; lshift(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator >> (const Integer& x, const Integer& y)
|
||||
inline Integer operator >> (const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; rshift(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator >> (const Integer& x, long y)
|
||||
inline Integer operator >> (const Integer& x, long y)
|
||||
{
|
||||
Integer r; rshift(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer pow(const Integer& x, long y)
|
||||
inline Integer pow(const Integer& x, long y)
|
||||
{
|
||||
Integer r; pow(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer Ipow(long x, long y)
|
||||
inline Integer Ipow(long x, long y)
|
||||
{
|
||||
Integer r(x); pow(r, y, r); return r;
|
||||
}
|
||||
|
||||
inline Integer pow(const Integer& x, const Integer& y)
|
||||
inline Integer pow(const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; pow(x, y, r); return r;
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Integer abs(const Integer& x)
|
||||
inline Integer abs(const Integer& x)
|
||||
{
|
||||
Integer r; abs(x, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator - (const Integer& x)
|
||||
inline Integer operator - (const Integer& x)
|
||||
{
|
||||
Integer r; negate(x, r); return r;
|
||||
}
|
||||
|
||||
inline Integer operator ~ (const Integer& x)
|
||||
inline Integer operator ~ (const Integer& x)
|
||||
{
|
||||
Integer r; complement(x, r); return r;
|
||||
}
|
||||
|
||||
inline Integer atoI(const char* s, int base)
|
||||
inline Integer atoI(const char* s, int base)
|
||||
{
|
||||
Integer r; r.rep = atoIntRep(s, base); return r;
|
||||
}
|
||||
|
||||
inline Integer gcd(const Integer& x, const Integer& y)
|
||||
inline Integer gcd(const Integer& x, const Integer& y)
|
||||
{
|
||||
Integer r; r.rep = gcd(x.rep, y.rep); return r;
|
||||
}
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -19,7 +19,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
#define _LogNormal_h
|
||||
#define _LogNormal_h
|
||||
|
||||
#include <Normal.h>
|
||||
|
||||
|
@ -44,7 +44,7 @@ inline void LogNormal::setState()
|
|||
pMean = log(m2 / sqrt(logVariance + m2) );
|
||||
// from ch@heike.informatik.uni-dortmund.de:
|
||||
// (was pVariance = log((sqrt(logVariance + m2)/m2 )); )
|
||||
pStdDev = sqrt(log((logVariance + m2)/m2 ));
|
||||
pStdDev = sqrt(log((logVariance + m2)/m2 ));
|
||||
}
|
||||
|
||||
inline LogNormal::LogNormal(double mean, double variance, RNG *gen)
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -16,7 +16,7 @@ License along with this library; if not, write to the Free Software
|
|||
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
#ifndef _MLCG_h
|
||||
#define _MLCG_h 1
|
||||
#define _MLCG_h 1
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -25,7 +25,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
//
|
||||
// Negative Exponential Random Numbers
|
||||
//
|
||||
//
|
||||
//
|
||||
|
||||
#include <Random.h>
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -19,7 +19,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
#define _Normal_h
|
||||
#define _Normal_h
|
||||
|
||||
#include <Random.h>
|
||||
|
||||
|
@ -31,7 +31,7 @@ class Normal: public Random {
|
|||
double pMean;
|
||||
double pVariance;
|
||||
double pStdDev;
|
||||
|
||||
|
||||
public:
|
||||
Normal(double xmean, double xvariance, RNG *gen);
|
||||
double mean();
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -84,127 +84,127 @@ class Obstack
|
|||
|
||||
inline Obstack::~Obstack()
|
||||
{
|
||||
_free(0);
|
||||
_free(0);
|
||||
}
|
||||
|
||||
inline void* Obstack::base()
|
||||
{
|
||||
return objectbase;
|
||||
return objectbase;
|
||||
}
|
||||
|
||||
inline void* Obstack::next_free()
|
||||
{
|
||||
return nextfree;
|
||||
return nextfree;
|
||||
}
|
||||
|
||||
inline int Obstack::alignment_mask()
|
||||
{
|
||||
return alignmentmask;
|
||||
return alignmentmask;
|
||||
}
|
||||
|
||||
inline int Obstack::chunk_size()
|
||||
{
|
||||
return chunksize;
|
||||
return chunksize;
|
||||
}
|
||||
|
||||
inline int Obstack::size()
|
||||
{
|
||||
return nextfree - objectbase;
|
||||
return nextfree - objectbase;
|
||||
}
|
||||
|
||||
inline int Obstack::room()
|
||||
{
|
||||
return chunklimit - nextfree;
|
||||
return chunklimit - nextfree;
|
||||
}
|
||||
|
||||
inline void Obstack:: grow(const void* data, int size)
|
||||
{
|
||||
if (nextfree+size > chunklimit)
|
||||
if (nextfree+size > chunklimit)
|
||||
newchunk(size);
|
||||
memcpy(nextfree, data, size);
|
||||
nextfree += size;
|
||||
nextfree += size;
|
||||
}
|
||||
|
||||
inline void Obstack:: grow(const void* data, int size, char terminator)
|
||||
{
|
||||
if (nextfree+size+1 > chunklimit)
|
||||
if (nextfree+size+1 > chunklimit)
|
||||
newchunk(size+1);
|
||||
memcpy(nextfree, data, size);
|
||||
nextfree += size;
|
||||
*(nextfree)++ = terminator;
|
||||
nextfree += size;
|
||||
*(nextfree)++ = terminator;
|
||||
}
|
||||
|
||||
inline void Obstack:: grow(const char* s)
|
||||
{
|
||||
grow((const void*)s, strlen(s), 0);
|
||||
grow((const void*)s, strlen(s), 0);
|
||||
}
|
||||
|
||||
inline void Obstack:: grow(char c)
|
||||
{
|
||||
if (nextfree+1 > chunklimit)
|
||||
newchunk(1);
|
||||
*(nextfree)++ = c;
|
||||
if (nextfree+1 > chunklimit)
|
||||
newchunk(1);
|
||||
*(nextfree)++ = c;
|
||||
}
|
||||
|
||||
inline void Obstack:: blank(int size)
|
||||
{
|
||||
if (nextfree+size > chunklimit)
|
||||
if (nextfree+size > chunklimit)
|
||||
newchunk(size);
|
||||
nextfree += size;
|
||||
nextfree += size;
|
||||
}
|
||||
|
||||
inline void* Obstack::finish(char terminator)
|
||||
{
|
||||
grow(terminator);
|
||||
return finish();
|
||||
grow(terminator);
|
||||
return finish();
|
||||
}
|
||||
|
||||
inline void* Obstack::copy(const void* data, int size)
|
||||
{
|
||||
grow (data, size);
|
||||
return finish();
|
||||
return finish();
|
||||
}
|
||||
|
||||
inline void* Obstack::copy(const void* data, int size, char terminator)
|
||||
{
|
||||
grow(data, size, terminator);
|
||||
return finish();
|
||||
grow(data, size, terminator);
|
||||
return finish();
|
||||
}
|
||||
|
||||
inline void* Obstack::copy(const char* s)
|
||||
{
|
||||
grow((const void*)s, strlen(s), 0);
|
||||
return finish();
|
||||
grow((const void*)s, strlen(s), 0);
|
||||
return finish();
|
||||
}
|
||||
|
||||
inline void* Obstack::copy(char c)
|
||||
{
|
||||
grow(c);
|
||||
return finish();
|
||||
return finish();
|
||||
}
|
||||
|
||||
inline void* Obstack::alloc(int size)
|
||||
{
|
||||
blank(size);
|
||||
return finish();
|
||||
return finish();
|
||||
}
|
||||
|
||||
inline void Obstack:: free(void* obj)
|
||||
inline void Obstack:: free(void* obj)
|
||||
{
|
||||
if (obj >= (void*)chunk && obj<(void*)chunklimit)
|
||||
nextfree = objectbase = (char *) obj;
|
||||
else
|
||||
_free(obj);
|
||||
else
|
||||
_free(obj);
|
||||
}
|
||||
|
||||
inline void Obstack:: grow_fast(char c)
|
||||
{
|
||||
*(nextfree)++ = c;
|
||||
*(nextfree)++ = c;
|
||||
}
|
||||
|
||||
inline void Obstack:: blank_fast(int size)
|
||||
{
|
||||
nextfree += size;
|
||||
nextfree += size;
|
||||
}
|
||||
|
||||
inline void Obstack:: shrink(int size) // from ken@cs.rochester.edu
|
||||
|
|
|
@ -22,10 +22,10 @@ the resulting executable to be covered by the GNU General Public License.
|
|||
This exception does not however invalidate any other reasons why
|
||||
the executable file might be covered by the GNU General Public License. */
|
||||
|
||||
/*
|
||||
/*
|
||||
a very simple implementation of a class to output unix "plot"
|
||||
format plotter files. See corresponding unix man pages for
|
||||
more details.
|
||||
more details.
|
||||
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
converted to use iostream library by Per Bothner (bothner@cygnus.com)
|
||||
|
@ -39,7 +39,7 @@ the executable file might be covered by the GNU General Public License. */
|
|||
|
||||
#include <fstream.h>
|
||||
|
||||
/*
|
||||
/*
|
||||
Some plot libraries have the `box' command to draw boxes. Some don't.
|
||||
`box' is included here via moves & lines to allow both possiblilties.
|
||||
*/
|
||||
|
@ -51,21 +51,21 @@ class PlotFile : public ofstream
|
|||
PlotFile& cmd(char c);
|
||||
PlotFile& operator << (const int x);
|
||||
PlotFile& operator << (const char *s);
|
||||
|
||||
|
||||
public:
|
||||
|
||||
|
||||
PlotFile() : ofstream() { }
|
||||
PlotFile(int fd) : ofstream(fd) { }
|
||||
PlotFile(const char *name, int mode=ios::out, int prot=0664)
|
||||
: ofstream(name, mode, prot) { }
|
||||
|
||||
|
||||
// PlotFile& remove() { ofstream::remove(); return *this; }
|
||||
|
||||
|
||||
// int filedesc() { return ofstream::filedesc(); }
|
||||
// const char* name() { return File::name(); }
|
||||
// void setname(const char* newname) { File::setname(newname); }
|
||||
// int iocount() { return File::iocount(); }
|
||||
|
||||
|
||||
PlotFile& arc(const int xi, const int yi,
|
||||
const int x0, const int y0,
|
||||
const int x1, const int y1);
|
||||
|
@ -75,7 +75,7 @@ class PlotFile : public ofstream
|
|||
PlotFile& cont(const int xi, const int yi);
|
||||
PlotFile& dot(const int xi, const int yi, const int dx,
|
||||
int n, const int* pat);
|
||||
PlotFile& erase();
|
||||
PlotFile& erase();
|
||||
PlotFile& label(const char* s);
|
||||
PlotFile& line(const int x0, const int y0,
|
||||
const int x1, const int y1);
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -19,7 +19,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
#define _Poisson_h
|
||||
#define _Poisson_h
|
||||
|
||||
#include <Random.h>
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -171,22 +171,22 @@ inline int operator != (const Rational& x, const Rational& y)
|
|||
|
||||
inline int operator < (const Rational& x, const Rational& y)
|
||||
{
|
||||
return compare(x, y) < 0;
|
||||
return compare(x, y) < 0;
|
||||
}
|
||||
|
||||
inline int operator <= (const Rational& x, const Rational& y)
|
||||
{
|
||||
return compare(x, y) <= 0;
|
||||
return compare(x, y) <= 0;
|
||||
}
|
||||
|
||||
inline int operator > (const Rational& x, const Rational& y)
|
||||
{
|
||||
return compare(x, y) > 0;
|
||||
return compare(x, y) > 0;
|
||||
}
|
||||
|
||||
inline int operator >= (const Rational& x, const Rational& y)
|
||||
{
|
||||
return compare(x, y) >= 0;
|
||||
return compare(x, y) >= 0;
|
||||
}
|
||||
|
||||
inline int sign(const Rational& x)
|
||||
|
@ -200,25 +200,25 @@ inline void Rational::negate()
|
|||
}
|
||||
|
||||
|
||||
inline Rational& Rational::operator += (const Rational& y)
|
||||
inline Rational& Rational::operator += (const Rational& y)
|
||||
{
|
||||
add(*this, y, *this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Rational& Rational::operator -= (const Rational& y)
|
||||
inline Rational& Rational::operator -= (const Rational& y)
|
||||
{
|
||||
sub(*this, y, *this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Rational& Rational::operator *= (const Rational& y)
|
||||
inline Rational& Rational::operator *= (const Rational& y)
|
||||
{
|
||||
mul(*this, y, *this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Rational& Rational::operator /= (const Rational& y)
|
||||
inline Rational& Rational::operator /= (const Rational& y)
|
||||
{
|
||||
div(*this, y, *this);
|
||||
return *this;
|
||||
|
@ -264,7 +264,7 @@ inline Rational operator / (const Rational& x, const Rational& y) return r
|
|||
|
||||
#else /* NO_NRV */
|
||||
|
||||
inline Rational operator + (const Rational& x, const Rational& y)
|
||||
inline Rational operator + (const Rational& x, const Rational& y)
|
||||
{
|
||||
Rational r; add(x, y, r); return r;
|
||||
}
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -44,15 +44,15 @@ class Regex
|
|||
re_registers* reg;
|
||||
|
||||
public:
|
||||
Regex(const char* t,
|
||||
int fast = 0,
|
||||
int bufsize = 40,
|
||||
Regex(const char* t,
|
||||
int fast = 0,
|
||||
int bufsize = 40,
|
||||
const char* transtable = 0);
|
||||
|
||||
~Regex();
|
||||
|
||||
int match(const char* s, int len, int pos = 0) const;
|
||||
int search(const char* s, int len,
|
||||
int search(const char* s, int len,
|
||||
int& matchlen, int startpos = 0) const;
|
||||
int match_info(int& start, int& length, int nth = 0) const;
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1990 Free Software Foundation
|
||||
adapted from a submission from John Reidl <riedl@cs.purdue.edu>
|
||||
|
||||
|
@ -40,13 +40,13 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
// in a specified range. By default the range is 0..1. Since in my
|
||||
// experience random numbers are often needed for a wide variety of
|
||||
// ranges in the same program, this generator accepts a new low or high value
|
||||
// as an argument to the asLong and operator() methods to temporarily
|
||||
// as an argument to the asLong and operator() methods to temporarily
|
||||
// override stored values
|
||||
|
||||
#include <math.h>
|
||||
#include <RNG.h>
|
||||
|
||||
class RandomInteger
|
||||
class RandomInteger
|
||||
{
|
||||
protected:
|
||||
RNG *pGenerator;
|
||||
|
@ -90,20 +90,20 @@ class RandomInteger
|
|||
};
|
||||
|
||||
|
||||
inline RandomInteger::RandomInteger(long low, long high, RNG *gen)
|
||||
inline RandomInteger::RandomInteger(long low, long high, RNG *gen)
|
||||
: pLow((low < high) ? low : high),
|
||||
pHigh((low < high) ? high : low),
|
||||
pGenerator(gen)
|
||||
{}
|
||||
|
||||
inline RandomInteger::RandomInteger(long high, RNG *gen)
|
||||
inline RandomInteger::RandomInteger(long high, RNG *gen)
|
||||
: pLow((0 < high) ? 0 : high),
|
||||
pHigh((0 < high) ? high : 0),
|
||||
pGenerator(gen)
|
||||
{}
|
||||
|
||||
|
||||
inline RandomInteger::RandomInteger(RNG *gen)
|
||||
|
||||
inline RandomInteger::RandomInteger(RNG *gen)
|
||||
: pLow(0),
|
||||
pHigh(1),
|
||||
pGenerator(gen)
|
||||
|
@ -113,28 +113,28 @@ inline RNG* RandomInteger::generator() const { return pGenerator;}
|
|||
inline long RandomInteger::low() const { return pLow; }
|
||||
inline long RandomInteger::high() const { return pHigh; }
|
||||
|
||||
inline RNG* RandomInteger::generator(RNG *gen)
|
||||
inline RNG* RandomInteger::generator(RNG *gen)
|
||||
{
|
||||
RNG *tmp = pGenerator; pGenerator = gen; return tmp;
|
||||
}
|
||||
|
||||
inline long RandomInteger::low(long x)
|
||||
inline long RandomInteger::low(long x)
|
||||
{
|
||||
long tmp = pLow; pLow = x; return tmp;
|
||||
}
|
||||
|
||||
inline long RandomInteger:: high(long x)
|
||||
inline long RandomInteger:: high(long x)
|
||||
{
|
||||
long tmp = pHigh; pHigh = x; return tmp;
|
||||
}
|
||||
|
||||
inline long RandomInteger:: _asLong(long low, long high)
|
||||
{
|
||||
{
|
||||
return (pGenerator->asLong() % (high-low+1)) + low;
|
||||
}
|
||||
|
||||
|
||||
inline long RandomInteger:: asLong()
|
||||
inline long RandomInteger:: asLong()
|
||||
{
|
||||
return _asLong(pLow, pHigh);
|
||||
}
|
||||
|
@ -149,7 +149,7 @@ inline long RandomInteger:: asLong(long low, long high)
|
|||
return _asLong(low, high);
|
||||
}
|
||||
|
||||
inline long RandomInteger:: operator () ()
|
||||
inline long RandomInteger:: operator () ()
|
||||
{
|
||||
return _asLong(pLow, pHigh);
|
||||
}
|
||||
|
@ -167,7 +167,7 @@ inline long RandomInteger:: operator () (long low, long high)
|
|||
|
||||
|
||||
|
||||
inline int RandomInteger:: asInt()
|
||||
inline int RandomInteger:: asInt()
|
||||
{
|
||||
return int(asLong());
|
||||
}
|
||||
|
|
|
@ -41,10 +41,10 @@ class SFile: public fstream
|
|||
SFile(int fd, int size);
|
||||
SFile(const char *name, int size, int mode, int prot=0664);
|
||||
void open(const char *name, int size, int mode, int prot=0664);
|
||||
|
||||
|
||||
int size() { return sz; }
|
||||
int setsize(int s) { int old = sz; sz = s; return old; }
|
||||
|
||||
|
||||
SFile& get(void* x);
|
||||
SFile& put(void* x);
|
||||
SFile& operator[](long i);
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988, 1992 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -104,7 +104,7 @@ class SLList : public BaseSLList
|
|||
Pix ins_after(Pix p, const T& item)
|
||||
{ return BaseSLList::ins_after(p, &item); }
|
||||
void join(SLList<T>& a) { BaseSLList::join(a); }
|
||||
|
||||
|
||||
T& front() {
|
||||
if (last == 0) error("front: empty list");
|
||||
return ((SLNode<T>*)last->tl)->hd; }
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -28,7 +28,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
extern const int SampleHistogramMinimum;
|
||||
extern const int SampleHistogramMaximum;
|
||||
|
||||
class SampleHistogram : public SampleStatistic
|
||||
class SampleHistogram : public SampleStatistic
|
||||
{
|
||||
protected:
|
||||
short howManyBuckets;
|
||||
|
@ -36,7 +36,7 @@ class SampleHistogram : public SampleStatistic
|
|||
double *bucketLimit;
|
||||
|
||||
public:
|
||||
|
||||
|
||||
SampleHistogram(double low, double hi, double bucketWidth = -1.0);
|
||||
|
||||
~SampleHistogram();
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -34,7 +34,7 @@ class SampleStatistic {
|
|||
|
||||
SampleStatistic();
|
||||
virtual ~SampleStatistic();
|
||||
virtual void reset();
|
||||
virtual void reset();
|
||||
|
||||
virtual void operator+=(double);
|
||||
int samples();
|
||||
|
@ -54,7 +54,7 @@ class SampleStatistic {
|
|||
extern void default_SampleStatistic_error_handler(const char*);
|
||||
extern one_arg_error_handler_t SampleStatistic_error_handler;
|
||||
|
||||
extern one_arg_error_handler_t
|
||||
extern one_arg_error_handler_t
|
||||
set_SampleStatistic_error_handler(one_arg_error_handler_t f);
|
||||
|
||||
inline SampleStatistic:: SampleStatistic(){ reset();}
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -28,9 +28,9 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
|
||||
struct StrRep // internal String representations
|
||||
{
|
||||
unsigned short len; // string length
|
||||
unsigned short len; // string length
|
||||
unsigned short sz; // allocated space
|
||||
char s[1]; // the string starts here
|
||||
char s[1]; // the string starts here
|
||||
// (at least 1 char for trailing null)
|
||||
// allocated & expanded via non-public fcts
|
||||
};
|
||||
|
@ -89,7 +89,7 @@ class SubString
|
|||
|
||||
int matches(const Regex& r) const;
|
||||
|
||||
// IO
|
||||
// IO
|
||||
|
||||
friend ostream& operator<<(ostream& s, const SubString& x);
|
||||
|
||||
|
@ -99,7 +99,7 @@ class SubString
|
|||
int empty() const;
|
||||
const char* chars() const;
|
||||
|
||||
int OK() const;
|
||||
int OK() const;
|
||||
|
||||
};
|
||||
|
||||
|
@ -140,12 +140,12 @@ class String
|
|||
|
||||
// concatenation
|
||||
|
||||
String& operator += (const String& y);
|
||||
String& operator += (const String& y);
|
||||
String& operator += (const SubString& y);
|
||||
String& operator += (const char* t);
|
||||
String& operator += (char c);
|
||||
|
||||
void prepend(const String& y);
|
||||
void prepend(const String& y);
|
||||
void prepend(const SubString& y);
|
||||
void prepend(const char* t);
|
||||
void prepend(char c);
|
||||
|
@ -169,7 +169,7 @@ class String
|
|||
friend inline void cat(const char*, const char*, String&);
|
||||
friend inline void cat(const char*, char, String&);
|
||||
|
||||
// double concatenation, by request. (yes, there are too many versions,
|
||||
// double concatenation, by request. (yes, there are too many versions,
|
||||
// but if one is supported, then the others should be too...)
|
||||
// Concatenate first 3 args, store in last arg
|
||||
|
||||
|
@ -204,11 +204,11 @@ class String
|
|||
|
||||
// return position of target in string or -1 for failure
|
||||
|
||||
int index(char c, int startpos = 0) const;
|
||||
int index(const String& y, int startpos = 0) const;
|
||||
int index(const SubString& y, int startpos = 0) const;
|
||||
int index(const char* t, int startpos = 0) const;
|
||||
int index(const Regex& r, int startpos = 0) const;
|
||||
int index(char c, int startpos = 0) const;
|
||||
int index(const String& y, int startpos = 0) const;
|
||||
int index(const SubString& y, int startpos = 0) const;
|
||||
int index(const char* t, int startpos = 0) const;
|
||||
int index(const Regex& r, int startpos = 0) const;
|
||||
|
||||
// return 1 if target appears anyhere in String; else 0
|
||||
|
||||
|
@ -218,7 +218,7 @@ class String
|
|||
int contains(const char* t) const;
|
||||
int contains(const Regex& r) const;
|
||||
|
||||
// return 1 if target appears anywhere after position pos
|
||||
// return 1 if target appears anywhere after position pos
|
||||
// (or before, if pos is negative) in String; else 0
|
||||
|
||||
int contains(char c, int pos) const;
|
||||
|
@ -237,7 +237,7 @@ class String
|
|||
|
||||
// return number of occurences of target in String
|
||||
|
||||
int freq(char c) const;
|
||||
int freq(char c) const;
|
||||
int freq(const String& y) const;
|
||||
int freq(const SubString& y) const;
|
||||
int freq(const char* t) const;
|
||||
|
@ -251,11 +251,11 @@ class String
|
|||
SubString at(int pos, int len);
|
||||
SubString operator () (int pos, int len); // synonym for at
|
||||
|
||||
SubString at(const String& x, int startpos = 0);
|
||||
SubString at(const SubString& x, int startpos = 0);
|
||||
SubString at(const String& x, int startpos = 0);
|
||||
SubString at(const SubString& x, int startpos = 0);
|
||||
SubString at(const char* t, int startpos = 0);
|
||||
SubString at(char c, int startpos = 0);
|
||||
SubString at(const Regex& r, int startpos = 0);
|
||||
SubString at(const Regex& r, int startpos = 0);
|
||||
|
||||
SubString before(int pos);
|
||||
SubString before(const String& x, int startpos = 0);
|
||||
|
@ -311,14 +311,14 @@ class String
|
|||
|
||||
// split string into array res at separators; return number of elements
|
||||
|
||||
friend int split(const String& x, String res[], int maxn,
|
||||
friend int split(const String& x, String res[], int maxn,
|
||||
const String& sep);
|
||||
friend int split(const String& x, String res[], int maxn,
|
||||
friend int split(const String& x, String res[], int maxn,
|
||||
const Regex& sep);
|
||||
|
||||
friend String common_prefix(const String& x, const String& y,
|
||||
friend String common_prefix(const String& x, const String& y,
|
||||
int startpos = 0);
|
||||
friend String common_suffix(const String& x, const String& y,
|
||||
friend String common_suffix(const String& x, const String& y,
|
||||
int startpos = -1);
|
||||
friend String replicate(char c, int n);
|
||||
friend String replicate(const String& y, int n);
|
||||
|
@ -358,7 +358,7 @@ class String
|
|||
friend ostream& operator<<(ostream& s, const SubString& x);
|
||||
friend istream& operator>>(istream& s, String& x);
|
||||
|
||||
friend int readline(istream& s, String& x,
|
||||
friend int readline(istream& s, String& x,
|
||||
char terminator = '\n',
|
||||
int discard_terminator = 1);
|
||||
|
||||
|
@ -409,17 +409,17 @@ inline const char* SubString::chars() const { return &(S.rep->s[pos]); }
|
|||
|
||||
// constructors
|
||||
|
||||
inline String::String()
|
||||
inline String::String()
|
||||
: rep(&_nilStrRep) {}
|
||||
inline String::String(const String& x)
|
||||
inline String::String(const String& x)
|
||||
: rep(Scopy(0, x.rep)) {}
|
||||
inline String::String(const char* t)
|
||||
inline String::String(const char* t)
|
||||
: rep(Salloc(0, t, -1, -1)) {}
|
||||
inline String::String(const char* t, int tlen)
|
||||
: rep(Salloc(0, t, tlen, tlen)) {}
|
||||
inline String::String(const SubString& y)
|
||||
: rep(Salloc(0, y.chars(), y.length(), y.length())) {}
|
||||
inline String::String(char c)
|
||||
inline String::String(char c)
|
||||
: rep(Salloc(0, &c, 1, 1)) {}
|
||||
|
||||
inline String::~String() { if (rep != &_nilStrRep) delete rep; }
|
||||
|
@ -434,7 +434,7 @@ inline SubString::~SubString() {}
|
|||
// assignment
|
||||
|
||||
inline String& String::operator = (const String& y)
|
||||
{
|
||||
{
|
||||
rep = Scopy(rep, y.rep);
|
||||
return *this;
|
||||
}
|
||||
|
@ -773,67 +773,67 @@ inline String operator + (const String& x, const String& y)
|
|||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const String& x, const SubString& y)
|
||||
inline String operator + (const String& x, const SubString& y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const String& x, const char* y)
|
||||
inline String operator + (const String& x, const char* y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const String& x, char y)
|
||||
inline String operator + (const String& x, char y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const SubString& x, const String& y)
|
||||
inline String operator + (const SubString& x, const String& y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const SubString& x, const SubString& y)
|
||||
inline String operator + (const SubString& x, const SubString& y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const SubString& x, const char* y)
|
||||
inline String operator + (const SubString& x, const char* y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const SubString& x, char y)
|
||||
inline String operator + (const SubString& x, char y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const char* x, const String& y)
|
||||
inline String operator + (const char* x, const String& y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String operator + (const char* x, const SubString& y)
|
||||
inline String operator + (const char* x, const SubString& y)
|
||||
{
|
||||
String r; cat(x, y, r); return r;
|
||||
}
|
||||
|
||||
inline String reverse(const String& x)
|
||||
inline String reverse(const String& x)
|
||||
{
|
||||
String r; r.rep = Sreverse(x.rep, r.rep); return r;
|
||||
}
|
||||
|
||||
inline String upcase(const String& x)
|
||||
inline String upcase(const String& x)
|
||||
{
|
||||
String r; r.rep = Supcase(x.rep, r.rep); return r;
|
||||
}
|
||||
|
||||
inline String downcase(const String& x)
|
||||
inline String downcase(const String& x)
|
||||
{
|
||||
String r; r.rep = Sdowncase(x.rep, r.rep); return r;
|
||||
}
|
||||
|
||||
inline String capitalize(const String& x)
|
||||
inline String capitalize(const String& x)
|
||||
{
|
||||
String r; r.rep = Scapitalize(x.rep, r.rep); return r;
|
||||
}
|
||||
|
@ -849,12 +849,12 @@ inline void String::prepend(const String& y)
|
|||
|
||||
inline void String::prepend(const char* y)
|
||||
{
|
||||
rep = Sprepend(rep, y, -1);
|
||||
rep = Sprepend(rep, y, -1);
|
||||
}
|
||||
|
||||
inline void String::prepend(char y)
|
||||
{
|
||||
rep = Sprepend(rep, &y, 1);
|
||||
rep = Sprepend(rep, &y, 1);
|
||||
}
|
||||
|
||||
inline void String::prepend(const SubString& y)
|
||||
|
@ -890,31 +890,31 @@ inline void String::capitalize()
|
|||
|
||||
// element extraction
|
||||
|
||||
inline char& String::operator [] (int i)
|
||||
{
|
||||
inline char& String::operator [] (int i)
|
||||
{
|
||||
if (((unsigned)i) >= length()) error("invalid index");
|
||||
return rep->s[i];
|
||||
}
|
||||
|
||||
inline const char& String::operator [] (int i) const
|
||||
{
|
||||
{
|
||||
if (((unsigned)i) >= length()) error("invalid index");
|
||||
return rep->s[i];
|
||||
}
|
||||
|
||||
inline char String::elem (int i) const
|
||||
{
|
||||
{
|
||||
if (((unsigned)i) >= length()) error("invalid index");
|
||||
return rep->s[i];
|
||||
}
|
||||
|
||||
inline char String::firstchar() const
|
||||
{
|
||||
{
|
||||
return elem(0);
|
||||
}
|
||||
|
||||
inline char String::lastchar() const
|
||||
{
|
||||
{
|
||||
return elem(length() - 1);
|
||||
}
|
||||
|
||||
|
@ -926,17 +926,17 @@ inline int String::index(char c, int startpos) const
|
|||
}
|
||||
|
||||
inline int String::index(const char* t, int startpos) const
|
||||
{
|
||||
{
|
||||
return search(startpos, length(), t);
|
||||
}
|
||||
|
||||
inline int String::index(const String& y, int startpos) const
|
||||
{
|
||||
{
|
||||
return search(startpos, length(), y.chars(), y.length());
|
||||
}
|
||||
|
||||
inline int String::index(const SubString& y, int startpos) const
|
||||
{
|
||||
{
|
||||
return search(startpos, length(), y.chars(), y.length());
|
||||
}
|
||||
|
||||
|
@ -951,17 +951,17 @@ inline int String::contains(char c) const
|
|||
}
|
||||
|
||||
inline int String::contains(const char* t) const
|
||||
{
|
||||
{
|
||||
return search(0, length(), t) >= 0;
|
||||
}
|
||||
|
||||
inline int String::contains(const String& y) const
|
||||
{
|
||||
{
|
||||
return search(0, length(), y.chars(), y.length()) >= 0;
|
||||
}
|
||||
|
||||
inline int String::contains(const SubString& y) const
|
||||
{
|
||||
{
|
||||
return search(0, length(), y.chars(), y.length()) >= 0;
|
||||
}
|
||||
|
||||
|
@ -1024,17 +1024,17 @@ inline int String::matches(const Regex& r, int p) const
|
|||
|
||||
|
||||
inline int SubString::contains(const char* t) const
|
||||
{
|
||||
{
|
||||
return S.search(pos, pos+len, t) >= 0;
|
||||
}
|
||||
|
||||
inline int SubString::contains(const String& y) const
|
||||
{
|
||||
{
|
||||
return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
|
||||
}
|
||||
|
||||
inline int SubString::contains(const SubString& y) const
|
||||
{
|
||||
{
|
||||
return S.search(pos, pos+len, y.chars(), y.length()) >= 0;
|
||||
}
|
||||
|
||||
|
@ -1088,99 +1088,99 @@ inline ostream& operator<<(ostream& s, const String& x)
|
|||
|
||||
// a zillion comparison operators
|
||||
|
||||
inline int operator==(const String& x, const String& y)
|
||||
inline int operator==(const String& x, const String& y)
|
||||
{
|
||||
return compare(x, y) == 0;
|
||||
return compare(x, y) == 0;
|
||||
}
|
||||
|
||||
inline int operator!=(const String& x, const String& y)
|
||||
{
|
||||
return compare(x, y) != 0;
|
||||
return compare(x, y) != 0;
|
||||
}
|
||||
|
||||
inline int operator>(const String& x, const String& y)
|
||||
{
|
||||
return compare(x, y) > 0;
|
||||
return compare(x, y) > 0;
|
||||
}
|
||||
|
||||
inline int operator>=(const String& x, const String& y)
|
||||
{
|
||||
return compare(x, y) >= 0;
|
||||
return compare(x, y) >= 0;
|
||||
}
|
||||
|
||||
inline int operator<(const String& x, const String& y)
|
||||
{
|
||||
return compare(x, y) < 0;
|
||||
return compare(x, y) < 0;
|
||||
}
|
||||
|
||||
inline int operator<=(const String& x, const String& y)
|
||||
{
|
||||
return compare(x, y) <= 0;
|
||||
return compare(x, y) <= 0;
|
||||
}
|
||||
|
||||
inline int operator==(const String& x, const SubString& y)
|
||||
inline int operator==(const String& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) == 0;
|
||||
return compare(x, y) == 0;
|
||||
}
|
||||
|
||||
inline int operator!=(const String& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) != 0;
|
||||
return compare(x, y) != 0;
|
||||
}
|
||||
|
||||
inline int operator>(const String& x, const SubString& y)
|
||||
inline int operator>(const String& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) > 0;
|
||||
return compare(x, y) > 0;
|
||||
}
|
||||
|
||||
inline int operator>=(const String& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) >= 0;
|
||||
return compare(x, y) >= 0;
|
||||
}
|
||||
|
||||
inline int operator<(const String& x, const SubString& y)
|
||||
inline int operator<(const String& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) < 0;
|
||||
return compare(x, y) < 0;
|
||||
}
|
||||
|
||||
inline int operator<=(const String& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) <= 0;
|
||||
return compare(x, y) <= 0;
|
||||
}
|
||||
|
||||
inline int operator==(const String& x, const char* t)
|
||||
inline int operator==(const String& x, const char* t)
|
||||
{
|
||||
return compare(x, t) == 0;
|
||||
return compare(x, t) == 0;
|
||||
}
|
||||
|
||||
inline int operator!=(const String& x, const char* t)
|
||||
inline int operator!=(const String& x, const char* t)
|
||||
{
|
||||
return compare(x, t) != 0;
|
||||
return compare(x, t) != 0;
|
||||
}
|
||||
|
||||
inline int operator>(const String& x, const char* t)
|
||||
inline int operator>(const String& x, const char* t)
|
||||
{
|
||||
return compare(x, t) > 0;
|
||||
return compare(x, t) > 0;
|
||||
}
|
||||
|
||||
inline int operator>=(const String& x, const char* t)
|
||||
inline int operator>=(const String& x, const char* t)
|
||||
{
|
||||
return compare(x, t) >= 0;
|
||||
return compare(x, t) >= 0;
|
||||
}
|
||||
|
||||
inline int operator<(const String& x, const char* t)
|
||||
inline int operator<(const String& x, const char* t)
|
||||
{
|
||||
return compare(x, t) < 0;
|
||||
return compare(x, t) < 0;
|
||||
}
|
||||
|
||||
inline int operator<=(const String& x, const char* t)
|
||||
inline int operator<=(const String& x, const char* t)
|
||||
{
|
||||
return compare(x, t) <= 0;
|
||||
return compare(x, t) <= 0;
|
||||
}
|
||||
|
||||
inline int operator==(const SubString& x, const String& y)
|
||||
inline int operator==(const SubString& x, const String& y)
|
||||
{
|
||||
return compare(y, x) == 0;
|
||||
return compare(y, x) == 0;
|
||||
}
|
||||
|
||||
inline int operator!=(const SubString& x, const String& y)
|
||||
|
@ -1188,29 +1188,29 @@ inline int operator!=(const SubString& x, const String& y)
|
|||
return compare(y, x) != 0;
|
||||
}
|
||||
|
||||
inline int operator>(const SubString& x, const String& y)
|
||||
inline int operator>(const SubString& x, const String& y)
|
||||
{
|
||||
return compare(y, x) < 0;
|
||||
}
|
||||
|
||||
inline int operator>=(const SubString& x, const String& y)
|
||||
inline int operator>=(const SubString& x, const String& y)
|
||||
{
|
||||
return compare(y, x) <= 0;
|
||||
}
|
||||
|
||||
inline int operator<(const SubString& x, const String& y)
|
||||
inline int operator<(const SubString& x, const String& y)
|
||||
{
|
||||
return compare(y, x) > 0;
|
||||
}
|
||||
|
||||
inline int operator<=(const SubString& x, const String& y)
|
||||
inline int operator<=(const SubString& x, const String& y)
|
||||
{
|
||||
return compare(y, x) >= 0;
|
||||
}
|
||||
|
||||
inline int operator==(const SubString& x, const SubString& y)
|
||||
inline int operator==(const SubString& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) == 0;
|
||||
return compare(x, y) == 0;
|
||||
}
|
||||
|
||||
inline int operator!=(const SubString& x, const SubString& y)
|
||||
|
@ -1218,7 +1218,7 @@ inline int operator!=(const SubString& x, const SubString& y)
|
|||
return compare(x, y) != 0;
|
||||
}
|
||||
|
||||
inline int operator>(const SubString& x, const SubString& y)
|
||||
inline int operator>(const SubString& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) > 0;
|
||||
}
|
||||
|
@ -1228,7 +1228,7 @@ inline int operator>=(const SubString& x, const SubString& y)
|
|||
return compare(x, y) >= 0;
|
||||
}
|
||||
|
||||
inline int operator<(const SubString& x, const SubString& y)
|
||||
inline int operator<(const SubString& x, const SubString& y)
|
||||
{
|
||||
return compare(x, y) < 0;
|
||||
}
|
||||
|
@ -1238,34 +1238,34 @@ inline int operator<=(const SubString& x, const SubString& y)
|
|||
return compare(x, y) <= 0;
|
||||
}
|
||||
|
||||
inline int operator==(const SubString& x, const char* t)
|
||||
inline int operator==(const SubString& x, const char* t)
|
||||
{
|
||||
return compare(x, t) == 0;
|
||||
return compare(x, t) == 0;
|
||||
}
|
||||
|
||||
inline int operator!=(const SubString& x, const char* t)
|
||||
inline int operator!=(const SubString& x, const char* t)
|
||||
{
|
||||
return compare(x, t) != 0;
|
||||
}
|
||||
|
||||
inline int operator>(const SubString& x, const char* t)
|
||||
inline int operator>(const SubString& x, const char* t)
|
||||
{
|
||||
return compare(x, t) > 0;
|
||||
return compare(x, t) > 0;
|
||||
}
|
||||
|
||||
inline int operator>=(const SubString& x, const char* t)
|
||||
inline int operator>=(const SubString& x, const char* t)
|
||||
{
|
||||
return compare(x, t) >= 0;
|
||||
return compare(x, t) >= 0;
|
||||
}
|
||||
|
||||
inline int operator<(const SubString& x, const char* t)
|
||||
inline int operator<(const SubString& x, const char* t)
|
||||
{
|
||||
return compare(x, t) < 0;
|
||||
return compare(x, t) < 0;
|
||||
}
|
||||
|
||||
inline int operator<=(const SubString& x, const char* t)
|
||||
inline int operator<=(const SubString& x, const char* t)
|
||||
{
|
||||
return compare(x, t) <= 0;
|
||||
return compare(x, t) <= 0;
|
||||
}
|
||||
|
||||
|
||||
|
@ -1275,7 +1275,7 @@ inline SubString String::_substr(int first, int l)
|
|||
{
|
||||
if (first < 0 || (unsigned)(first + l) > length() )
|
||||
return SubString(_nilString, 0, 0) ;
|
||||
else
|
||||
else
|
||||
return SubString(*this, first, l);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -25,7 +25,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
|
||||
//
|
||||
// The interval [lo..hi]
|
||||
//
|
||||
//
|
||||
|
||||
class Uniform: public Random {
|
||||
double pLow;
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Dirk Grunwald (grunwald@cs.uiuc.edu)
|
||||
|
||||
|
@ -19,7 +19,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
#define _Weibull_h
|
||||
#define _Weibull_h
|
||||
|
||||
#include <Random.h>
|
||||
|
||||
|
@ -30,7 +30,7 @@ class Weibull: public Random {
|
|||
double pBeta;
|
||||
|
||||
void setState();
|
||||
|
||||
|
||||
public:
|
||||
Weibull(double alpha, double beta, RNG *gen);
|
||||
|
||||
|
@ -47,7 +47,7 @@ class Weibull: public Random {
|
|||
inline void Weibull::setState() {
|
||||
pInvAlpha = 1.0 / pAlpha;
|
||||
}
|
||||
|
||||
|
||||
inline Weibull::Weibull(double alpha, double beta, RNG *gen) : Random(gen)
|
||||
{
|
||||
pAlpha = alpha;
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* AUTOMATICALLY GENERATED; DO NOT EDIT! */
|
||||
/* AUTOMATICALLY GENERATED; DO NOT EDIT! */
|
||||
#include <sys/types.h>
|
||||
#ifndef _G_config_h
|
||||
#define _G_config_h
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988, 1992 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -42,7 +42,7 @@ typedef void (*one_arg_error_handler_t)(const char*);
|
|||
typedef void (*two_arg_error_handler_t)(const char*, const char*);
|
||||
|
||||
long gcd(long, long);
|
||||
long lg(unsigned long);
|
||||
long lg(unsigned long);
|
||||
double pow(double, long);
|
||||
long pow(long, long);
|
||||
|
||||
|
@ -60,30 +60,30 @@ extern _VOLATILE_VOID default_two_arg_error_handler(const char*, const char*);
|
|||
|
||||
extern two_arg_error_handler_t lib_error_handler;
|
||||
|
||||
extern two_arg_error_handler_t
|
||||
extern two_arg_error_handler_t
|
||||
set_lib_error_handler(two_arg_error_handler_t f);
|
||||
|
||||
|
||||
#if !defined(IV)
|
||||
|
||||
#if ! _G_MATH_H_INLINES /* hpux and SCO define this in math.h */
|
||||
inline double abs(double arg)
|
||||
inline double abs(double arg)
|
||||
{
|
||||
return (arg < 0.0)? -arg : arg;
|
||||
}
|
||||
#endif
|
||||
|
||||
inline float abs(float arg)
|
||||
inline float abs(float arg)
|
||||
{
|
||||
return (arg < 0.0)? -arg : arg;
|
||||
}
|
||||
|
||||
inline short abs(short arg)
|
||||
inline short abs(short arg)
|
||||
{
|
||||
return (arg < 0)? -arg : arg;
|
||||
}
|
||||
|
||||
inline long abs(long arg)
|
||||
inline long abs(long arg)
|
||||
{
|
||||
return (arg < 0)? -arg : arg;
|
||||
}
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1994 Free Software Foundation
|
||||
written by Jason Merrill (jason@cygnus.com)
|
||||
|
||||
|
|
|
@ -39,9 +39,9 @@ typedef /*unsigned*/ char buf_char;
|
|||
|
||||
// Logical pos from start of buffer (does not count gap).
|
||||
typedef long buf_index;
|
||||
|
||||
|
||||
// Pos from start of buffer, possibly including gap_size.
|
||||
typedef long buf_offset;
|
||||
typedef long buf_offset;
|
||||
|
||||
#if 0
|
||||
struct buf_cookie {
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
|
|
@ -42,10 +42,10 @@ template<class TP> class smanip; // TP = Type Param
|
|||
|
||||
template<class TP> class sapp {
|
||||
ios& (*_f)(ios&, TP);
|
||||
public:
|
||||
public:
|
||||
sapp(ios& (*f)(ios&, TP)) : _f(f) {}
|
||||
//
|
||||
smanip<TP> operator()(TP a)
|
||||
smanip<TP> operator()(TP a)
|
||||
{ return smanip<TP>(_f, a); }
|
||||
};
|
||||
|
||||
|
@ -55,7 +55,7 @@ template <class TP> class smanip {
|
|||
public:
|
||||
smanip(ios& (*f)(ios&, TP), TP a) : _f(f), _a(a) {}
|
||||
//
|
||||
friend
|
||||
friend
|
||||
istream& operator>>(istream& i, const smanip<TP>& m);
|
||||
friend
|
||||
ostream& operator<<(ostream& o, const smanip<TP>& m);
|
||||
|
@ -85,11 +85,11 @@ extern template ostream& operator<<(ostream&, const smanip<ios::fmtflags>&);
|
|||
// Input-Stream Manipulators
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
template<class TP> class imanip;
|
||||
template<class TP> class imanip;
|
||||
|
||||
template<class TP> class iapp {
|
||||
istream& (*_f)(istream&, TP);
|
||||
public:
|
||||
public:
|
||||
iapp(istream& (*f)(istream&,TP)) : _f(f) {}
|
||||
//
|
||||
imanip<TP> operator()(TP a)
|
||||
|
@ -102,7 +102,7 @@ template <class TP> class imanip {
|
|||
public:
|
||||
imanip(istream& (*f)(istream&, TP), TP a) : _f(f), _a(a) {}
|
||||
//
|
||||
friend
|
||||
friend
|
||||
istream& operator>>(istream& i, const imanip<TP>& m)
|
||||
{ return (*m._f)( i, m._a); }
|
||||
};
|
||||
|
@ -112,11 +112,11 @@ template <class TP> class imanip {
|
|||
// Output-Stream Manipulators
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
template<class TP> class omanip;
|
||||
template<class TP> class omanip;
|
||||
|
||||
template<class TP> class oapp {
|
||||
ostream& (*_f)(ostream&, TP);
|
||||
public:
|
||||
public:
|
||||
oapp(ostream& (*f)(ostream&,TP)) : _f(f) {}
|
||||
//
|
||||
omanip<TP> operator()(TP a)
|
||||
|
@ -141,7 +141,7 @@ template <class TP> class omanip {
|
|||
|
||||
//
|
||||
// Macro to define an iomanip function, with one argument
|
||||
// The underlying function is `__iomanip_<name>'
|
||||
// The underlying function is `__iomanip_<name>'
|
||||
//
|
||||
#define __DEFINE_IOMANIP_FN1(type,param,function) \
|
||||
extern ios& __iomanip_##function (ios&, param); \
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* This is part of libio/iostream, providing -*- C++ -*- input/output.
|
||||
/* This is part of libio/iostream, providing -*- C++ -*- input/output.
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
@ -185,21 +185,21 @@ struct _IO_FILE {
|
|||
char *_IO_save_end; /* Pointer to end of non-current get area. */
|
||||
|
||||
struct _IO_marker *_markers;
|
||||
|
||||
|
||||
struct _IO_FILE *_chain;
|
||||
|
||||
|
||||
struct _IO_jump_t *_jumps; /* Jump table */
|
||||
|
||||
|
||||
int _fileno;
|
||||
int _blksize;
|
||||
_IO_off_t _offset;
|
||||
|
||||
|
||||
#define __HAVE_COLUMN /* temporary */
|
||||
/* 1+column number of pbase(); 0 is unknown. */
|
||||
unsigned short _cur_column;
|
||||
char _unused;
|
||||
char _shortbuf[1];
|
||||
|
||||
|
||||
/* char* _save_gptr; char* _save_egptr; */
|
||||
};
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
|
|
@ -67,7 +67,7 @@ class parsebuf : public streambuf {
|
|||
|
||||
// Length of current line, not counting either '\n'.
|
||||
int line_length() { return _line_length; }
|
||||
// Current line - not a copy, so file ops may trash it.
|
||||
// Current line - not a copy, so file ops may trash it.
|
||||
virtual char* current_line();
|
||||
virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
|
||||
virtual streambuf* setbuf(char* p, int len);
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -1,5 +1,5 @@
|
|||
// This may look like C code, but it is really -*- C++ -*-
|
||||
/*
|
||||
/*
|
||||
Copyright (C) 1988, 1992 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -24,7 +24,7 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdio.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
|
@ -32,4 +32,4 @@ extern "C" {
|
|||
int strcasecmp _G_ARGS((const char*, const char*));
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
|
|
@ -314,7 +314,7 @@ struct streambuf : public _IO_FILE { // protected??
|
|||
void setp(char* p, char* ep)
|
||||
{ _IO_write_base=_IO_write_ptr=p; _IO_write_end=ep; }
|
||||
void setg(char* eb, char* g, char *eg) {
|
||||
if (_IO_file_flags & _IO_IN_BACKUP) _IO_free_backup_area(this);
|
||||
if (_IO_file_flags & _IO_IN_BACKUP) _IO_free_backup_area(this);
|
||||
_IO_read_base = eb; _IO_read_ptr = g; _IO_read_end = eg; }
|
||||
char *shortbuf() { return _shortbuf; }
|
||||
|
||||
|
@ -336,7 +336,7 @@ struct streambuf : public _IO_FILE { // protected??
|
|||
void unsave_markers(); // Make all streammarkers !saving().
|
||||
int put_mode() { return _flags & _IO_CURRENTLY_PUTTING; }
|
||||
int switch_to_get_mode();
|
||||
|
||||
|
||||
streambuf(int flags=0);
|
||||
public:
|
||||
static int flush_all();
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1993 Free Software Foundation
|
||||
|
||||
This file is part of the GNU IO Library. This library is free
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/*
|
||||
/*
|
||||
Copyright (C) 1990, 1992 Free Software Foundation
|
||||
written by Doug Lea (dl@rocky.oswego.edu)
|
||||
|
||||
|
@ -22,9 +22,9 @@ Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|||
/* Timing functions from Doug Schmidt... */
|
||||
|
||||
/* no such thing as "negative time"! */
|
||||
#define TIMER_ERROR_VALUE -1.0
|
||||
#define TIMER_ERROR_VALUE -1.0
|
||||
|
||||
/* If this does not work on your system, change this to #if 0, and
|
||||
/* If this does not work on your system, change this to #if 0, and
|
||||
report the problem. */
|
||||
|
||||
#if 1
|
||||
|
@ -73,7 +73,7 @@ return_elapsed_time(Last_Time)
|
|||
{
|
||||
if (!Timer_Set) {
|
||||
return(TIMER_ERROR_VALUE);
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* get process time */
|
||||
#ifdef USE_TIMES
|
||||
|
@ -85,8 +85,8 @@ return_elapsed_time(Last_Time)
|
|||
#ifdef USE_TIMES
|
||||
return((double) (New_Time.tms_utime - Old_Time.tms_utime) / HZ);
|
||||
#else
|
||||
return((New_Time.ru_utime.tv_sec - Old_Time.ru_utime.tv_sec) +
|
||||
((New_Time.ru_utime.tv_usec - Old_Time.ru_utime.tv_usec)
|
||||
return((New_Time.ru_utime.tv_sec - Old_Time.ru_utime.tv_sec) +
|
||||
((New_Time.ru_utime.tv_usec - Old_Time.ru_utime.tv_usec)
|
||||
/ 1000000.0));
|
||||
#endif
|
||||
}
|
||||
|
@ -94,7 +94,7 @@ return_elapsed_time(Last_Time)
|
|||
#ifdef USE_TIMES
|
||||
return((double) New_Time.tms_utime / HZ - Last_Time);
|
||||
#else
|
||||
return((New_Time.ru_utime.tv_sec +
|
||||
return((New_Time.ru_utime.tv_sec +
|
||||
(New_Time.ru_utime.tv_usec / 1000000.0)) - Last_Time);
|
||||
#endif
|
||||
}
|
||||
|
@ -115,7 +115,7 @@ getrusage(int dummy,struct rusage* time){
|
|||
/* we subtract an offset to make sure that the number fits in a long int*/
|
||||
rtime=rtime/1.0e+7-4.144e+9;
|
||||
time->ru_utime.tv_sec= rtime;
|
||||
rtime=(rtime-time->ru_utime.tv_sec)*1.0e6;
|
||||
rtime=(rtime-time->ru_utime.tv_sec)*1.0e6;
|
||||
time->ru_utime.tv_usec= rtime;
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -666,7 +666,7 @@ strerror (errnoval)
|
|||
/* In range, and a valid message. Just return the message. */
|
||||
msg = (char *) sys_errlist[errnoval];
|
||||
}
|
||||
|
||||
|
||||
return (msg);
|
||||
}
|
||||
|
||||
|
|
|
@ -448,7 +448,7 @@ strsignal (signo)
|
|||
/* In range, and a valid message. Just return the message. */
|
||||
msg = (const char *) sys_siglist[signo];
|
||||
}
|
||||
|
||||
|
||||
return (msg);
|
||||
}
|
||||
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue