nethack-gwaa-kiwi/nethack
1
0
Fork 0
Code Pull Requests Activity

Reformat all C files.

Browse Source 
I'll push a formatting guide at some point. There may still be
outstanding changes, but please feel free to resolve those as you arrive
a them.

To the best of my knowledge, there is no changes to the actual code
content, but the formatter does have the occasional bug. If you run into
an issue, please fix it!
This commit is contained in:
Sean Hunt
2015-05-09 13:43:16 -04:00
parent 167800afdf
commit 97d6fade74
270 changed files with 182649 additions and 173878 deletions
Download Patch File Download Diff File Expand all files Collapse all files

345
sys/share/random.c
View File

@@ -33,16 +33,16 @@
* - cast result of pointer subtraction to long since ptrdiff_t could
* be bigger than that and trigger warnings when assigning to long
*
* $NHDT-Date$ $NHDT-Branch$:$NHDT-Revision$
* $NHDT-Date: 1431192779 2015/05/09 17:32:59 $ $NHDT-Branch: master $:$NHDT-Revision: 1.4 $
* $Date: 2007/12/23 00:59:25 $ $Revision: 1.2 $
*/
#include "hack.h"
#ifdef LIBC_SCCS
# ifndef lint
#ifndef lint
static char sccsid[] = "@(#)random.c 5.5 (Berkeley) 7/6/88";
# endif
#endif
#endif /* LIBC_SCCS and not lint */
/*
@@ -50,11 +50,13 @@ static char sccsid[] = "@(#)random.c 5.5 (Berkeley) 7/6/88";
* An improved random number generation package. In addition to the standard
* rand()/srand() like interface, this package also has a special state info
* interface. The initstate() routine is called with a seed, an array of
* bytes, and a count of how many bytes are being passed in; this array is then
* bytes, and a count of how many bytes are being passed in; this array is
* then
* initialized to contain information for random number generation with that
* much state information. Good sizes for the amount of state information are
* 32, 64, 128, and 256 bytes. The state can be switched by calling the
* setstate() routine with the same array as was initiallized with initstate().
* setstate() routine with the same array as was initiallized with
* initstate().
* By default, the package runs with 128 bytes of state information and
* generates far better random numbers than a linear congruential generator.
* If the amount of state information is less than 32 bytes, a simple linear
@@ -63,7 +65,7 @@ static char sccsid[] = "@(#)random.c 5.5 (Berkeley) 7/6/88";
* zeroeth element of the array is the type of R.N.G. being used (small
* integer); the remainder of the array is the state information for the
* R.N.G. Thus, 32 bytes of state information will give 7 longs worth of
* state information, which will allow a degree seven polynomial. (Note: the
* state information, which will allow a degree seven polynomial. (Note: the
* zeroeth word of state information also has some other information stored
* in it -- see setstate() for details).
* The random number generation technique is a linear feedback shift register
@@ -82,8 +84,6 @@ static char sccsid[] = "@(#)random.c 5.5 (Berkeley) 7/6/88";
* predicted by this formula.
*/
/*
* For each of the currently supported random number generators, we have a
* break value on the amount of state information (you need at least this
@@ -92,46 +92,41 @@ static char sccsid[] = "@(#)random.c 5.5 (Berkeley) 7/6/88";
* the separation between the two lower order coefficients of the trinomial.
*/
#define TYPE_0 0 /* linear congruential */
#define BREAK_0 8
#define DEG_0 0
#define SEP_0 0
#define TYPE_0 0 /* linear congruential */
#define BREAK_0 8
#define DEG_0 0
#define SEP_0 0
#define TYPE_1 1 /* x**7 + x**3 + 1 */
#define BREAK_1 32
#define DEG_1 7
#define SEP_1 3
#define TYPE_1 1 /* x**7 + x**3 + 1 */
#define BREAK_1 32
#define DEG_1 7
#define SEP_1 3
#define TYPE_2 2 /* x**15 + x + 1 */
#define BREAK_2 64
#define DEG_2 15
#define SEP_2 1
#define TYPE_2 2 /* x**15 + x + 1 */
#define BREAK_2 64
#define DEG_2 15
#define SEP_2 1
#define TYPE_3 3 /* x**31 + x**3 + 1 */
#define BREAK_3 128
#define DEG_3 31
#define SEP_3 3
#define TYPE_4 4 /* x**63 + x + 1 */
#define BREAK_4 256
#define DEG_4 63
#define SEP_4 1
#define TYPE_3 3 /* x**31 + x**3 + 1 */
#define BREAK_3 128
#define DEG_3 31
#define SEP_3 3
#define TYPE_4 4 /* x**63 + x + 1 */
#define BREAK_4 256
#define DEG_4 63
#define SEP_4 1
/*
* Array versions of the above information to make code run faster -- relies
* on fact that TYPE_i == i.
*/
#define MAX_TYPES 5 /* max number of types above */
static int degrees[ MAX_TYPES ] = { DEG_0, DEG_1, DEG_2,
DEG_3, DEG_4 };
static int seps[ MAX_TYPES ] = { SEP_0, SEP_1, SEP_2,
SEP_3, SEP_4 };
#define MAX_TYPES 5 /* max number of types above */
static int degrees[MAX_TYPES] = { DEG_0, DEG_1, DEG_2, DEG_3, DEG_4 };
static int seps[MAX_TYPES] = { SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 };
/*
* Initially, everything is set up as if from :
@@ -144,21 +139,23 @@ static int seps[ MAX_TYPES ] = { SEP_0, SEP_1, SEP_2,
* MAX_TYPES*(rptr - state) + TYPE_3 == TYPE_3.
*/
static long randtbl[ DEG_3 + 1 ] = { TYPE_3,
0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342,
0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb,
0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86,
0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7,
0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b,
0xf5ad9d0e, 0x8999220b, 0x27fb47b9 };
static long randtbl[DEG_3 + 1] = {
TYPE_3, 0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 0xde3b81e0,
0xdf0a6fb5, 0xf103bc02, 0x48f340fb, 0x7449e56b, 0xbeb1dbb0, 0xab5c5918,
0x946554fd, 0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 0xda672e2a,
0x1588ca88, 0xe369735d, 0x904f35f7, 0xd7158fd6, 0x6fa6f051, 0x616e6b96,
0xac94efdc, 0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 0xf5ad9d0e,
0x8999220b, 0x27fb47b9
};
/*
* fptr and rptr are two pointers into the state info, a front and a rear
* pointer. These two pointers are always rand_sep places aparts, as they cycle
* cyclically through the state information. (Yes, this does mean we could get
* away with just one pointer, but the code for random() is more efficient this
* pointer. These two pointers are always rand_sep places aparts, as they
*cycle
* cyclically through the state information. (Yes, this does mean we could
*get
* away with just one pointer, but the code for random() is more efficient
*this
* way). The pointers are left positioned as they would be from the call
* initstate( 1, randtbl, 128 )
* (The position of the rear pointer, rptr, is really 0 (as explained above
@@ -166,10 +163,8 @@ static long randtbl[ DEG_3 + 1 ] = { TYPE_3,
* to point to randtbl[1] (as explained below).
*/
static long *fptr = &randtbl[ SEP_3 + 1 ];
static long *rptr = &randtbl[ 1 ];
static long *fptr = &randtbl[SEP_3 + 1];
static long *rptr = &randtbl[1];
/*
* The following things are the pointer to the state information table,
@@ -183,15 +178,13 @@ static long *rptr = &randtbl[ 1 ];
* the front and rear pointers have wrapped.
*/
static long *state = &randtbl[ 1 ];
static int rand_type = TYPE_3;
static int rand_deg = DEG_3;
static int rand_sep = SEP_3;
static long *end_ptr = &randtbl[ DEG_3 + 1 ];
static long *state = &randtbl[1];
static int rand_type = TYPE_3;
static int rand_deg = DEG_3;
static int rand_sep = SEP_3;
static long *end_ptr = &randtbl[DEG_3 + 1];
/*
* srandom:
@@ -207,28 +200,26 @@ static long *end_ptr = &randtbl[ DEG_3 + 1 ];
*/
void
srandom( x )
srandom(x)
unsigned x;
unsigned x;
{
register int i;
register int i;
if( rand_type == TYPE_0 ) {
state[ 0 ] = x;
}
else {
state[ 0 ] = x;
for( i = 1; i < rand_deg; i++ ) {
state[i] = 1103515245*state[i - 1] + 12345;
}
fptr = &state[ rand_sep ];
rptr = &state[ 0 ];
for( i = 0; i < 10*rand_deg; i++ ) random();
}
if (rand_type == TYPE_0) {
state[0] = x;
} else {
state[0] = x;
for (i = 1; i < rand_deg; i++) {
state[i] = 1103515245 * state[i - 1] + 12345;
}
fptr = &state[rand_sep];
rptr = &state[0];
for (i = 0; i < 10 * rand_deg; i++)
random();
}
}
/*
* initstate:
* Initialize the state information in the given array of n bytes for
@@ -245,63 +236,62 @@ srandom( x )
* Returns a pointer to the old state.
*/
char *
initstate( seed, arg_state, n )
char *
initstate(seed, arg_state, n)
unsigned seed; /* seed for R. N. G. */
char *arg_state; /* pointer to state array */
int n; /* # bytes of state info */
unsigned seed; /* seed for R. N. G. */
char *arg_state; /* pointer to state array */
int n; /* # bytes of state info */
{
register char *ostate = (char *)( &state[ -1 ] );
register char *ostate = (char *) (&state[-1]);
if( rand_type == TYPE_0 ) state[ -1 ] = rand_type;
else state[ -1 ] = (long)(MAX_TYPES*(rptr - state) + rand_type);
if( n < BREAK_1 ) {
if( n < BREAK_0 ) {
impossible(
"initstate: not enough state (%d bytes) with which to do jack; ignored.", n);
return (char *)0;
}
rand_type = TYPE_0;
rand_deg = DEG_0;
rand_sep = SEP_0;
}
else {
if( n < BREAK_2 ) {
rand_type = TYPE_1;
rand_deg = DEG_1;
rand_sep = SEP_1;
}
else {
if( n < BREAK_3 ) {
rand_type = TYPE_2;
rand_deg = DEG_2;
rand_sep = SEP_2;
}
else {
if( n < BREAK_4 ) {
rand_type = TYPE_3;
rand_deg = DEG_3;
rand_sep = SEP_3;
}
else {
rand_type = TYPE_4;
rand_deg = DEG_4;
rand_sep = SEP_4;
}
}
}
}
state = &( ( (long *)arg_state )[1] ); /* first location */
end_ptr = &state[ rand_deg ]; /* must set end_ptr before srandom */
srandom( seed );
if( rand_type == TYPE_0 ) state[ -1 ] = rand_type;
else state[ -1 ] = (long)(MAX_TYPES*(rptr - state) + rand_type);
return( ostate );
if (rand_type == TYPE_0)
state[-1] = rand_type;
else
state[-1] = (long) (MAX_TYPES * (rptr - state) + rand_type);
if (n < BREAK_1) {
if (n < BREAK_0) {
impossible("initstate: not enough state (%d bytes) with which to "
"do jack; ignored.",
n);
return (char *) 0;
}
rand_type = TYPE_0;
rand_deg = DEG_0;
rand_sep = SEP_0;
} else {
if (n < BREAK_2) {
rand_type = TYPE_1;
rand_deg = DEG_1;
rand_sep = SEP_1;
} else {
if (n < BREAK_3) {
rand_type = TYPE_2;
rand_deg = DEG_2;
rand_sep = SEP_2;
} else {
if (n < BREAK_4) {
rand_type = TYPE_3;
rand_deg = DEG_3;
rand_sep = SEP_3;
} else {
rand_type = TYPE_4;
rand_deg = DEG_4;
rand_sep = SEP_4;
}
}
}
}
state = &(((long *) arg_state)[1]); /* first location */
end_ptr = &state[rand_deg]; /* must set end_ptr before srandom */
srandom(seed);
if (rand_type == TYPE_0)
state[-1] = rand_type;
else
state[-1] = (long) (MAX_TYPES * (rptr - state) + rand_type);
return (ostate);
}
/*
* setstate:
* Restore the state from the given state array.
@@ -314,44 +304,45 @@ initstate( seed, arg_state, n )
* Returns a pointer to the old state information.
*/
char *
setstate( arg_state )
char *
setstate(arg_state)
char *arg_state;
char *arg_state;
{
register long *new_state = (long *)arg_state;
register int type = new_state[0]%MAX_TYPES;
register int rear = new_state[0]/MAX_TYPES;
char *ostate = (char *)( &state[ -1 ] );
register long *new_state = (long *) arg_state;
register int type = new_state[0] % MAX_TYPES;
register int rear = new_state[0] / MAX_TYPES;
char *ostate = (char *) (&state[-1]);
if( rand_type == TYPE_0 ) state[ -1 ] = rand_type;
else state[ -1 ] = (long)(MAX_TYPES*(rptr - state) + rand_type);
switch( type ) {
case TYPE_0:
case TYPE_1:
case TYPE_2:
case TYPE_3:
case TYPE_4:
rand_type = type;
rand_deg = degrees[ type ];
rand_sep = seps[ type ];
break;
if (rand_type == TYPE_0)
state[-1] = rand_type;
else
state[-1] = (long) (MAX_TYPES * (rptr - state) + rand_type);
switch (type) {
case TYPE_0:
case TYPE_1:
case TYPE_2:
case TYPE_3:
case TYPE_4:
rand_type = type;
rand_deg = degrees[type];
rand_sep = seps[type];
break;
default:
impossible("setstate: state info has been munged (%d); not changed.", type);
break;
}
state = &new_state[ 1 ];
if( rand_type != TYPE_0 ) {
rptr = &state[ rear ];
fptr = &state[ (rear + rand_sep)%rand_deg ];
}
end_ptr = &state[ rand_deg ]; /* set end_ptr too */
return( ostate );
default:
impossible("setstate: state info has been munged (%d); not changed.",
type);
break;
}
state = &new_state[1];
if (rand_type != TYPE_0) {
rptr = &state[rear];
fptr = &state[(rear + rand_sep) % rand_deg];
}
end_ptr = &state[rand_deg]; /* set end_ptr too */
return (ostate);
}
/*
* random:
* If we are using the trivial TYPE_0 R.N.G., just do the old linear
@@ -370,22 +361,20 @@ setstate( arg_state )
long
random()
{
long i;
if( rand_type == TYPE_0 ) {
i = state[0] = ( state[0]*1103515245 + 12345 )&0x7fffffff;
}
else {
*fptr += *rptr;
i = (*fptr >> 1)&0x7fffffff; /* chucking least random bit */
if( ++fptr >= end_ptr ) {
fptr = state;
++rptr;
}
else {
if( ++rptr >= end_ptr ) rptr = state;
}
}
return( i );
}
long i;
if (rand_type == TYPE_0) {
i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff;
} else {
*fptr += *rptr;
i = (*fptr >> 1) & 0x7fffffff; /* chucking least random bit */
if (++fptr >= end_ptr) {
fptr = state;
++rptr;
} else {
if (++rptr >= end_ptr)
rptr = state;
}
}
return (i);
}