/*
 * File name hw4.h
 * 5 macros for Allen Holub's C for Professionals class.
 * Homework 4. October 15, 1990.
 *
 * Explanations of the macros which follow:
 *
 * wlen() evaluates to the number of bits used by the C implementation on 
 *	the host machine to store an int.  wlen() assumes that this number 
 *	is a multiple of 4 and is in the range 4 <= size <= 32.  The macro
 *	works by shifting a bit left into each of 7 possible positions.  
 *	If that bit position exists, 4 is added to the number of bits in 
 *	an int.  Otherwise the bit is shifted "into space" and 0 is added 
 *	to the number of bits in an int.
 *
 * biggest() evaluates to a long that holds the largest positive value of an 
 *	int on the host machine.  The macro works by making use of the fact
 *	that the largest signed int will have a zero in the highest bit 
 *	position and ones in all of the others.  An unsigned int is shifted
 *	right to avoid the possibility of sign extension.
 *
 * smallest() evaluates to a long that holds the smallest negative value of 
 *	an int on the host machine.  The macro works by making use of the 
 *	fact that the smallest signed int will have a one in the highest bit
 *	position followed by zeros in all of the others.  An unsigned int is
 *	shifted right to avoid the possibility of sign extension.
 *
 * rrot(x,nbits) rotates x, nbits to the right.  For example, if an int is 
 *	16 bits, then rrot(0x2345, 4) yields 0x5234.  The macro works by
 *	shifting right by the number of bits specified and ORing the result
 *	with the number shifted left by the number of bits in an int minus 
 *	the number of bits used to shift right.
 *	Bugs: rotating by a number of bits outside of the range from 0 
 *	through the number of bits in an int gives unpredictable results.  
 *	rrot() works only with numbers which are the same size as an int.  
 *	Assumes the same limitations on the size of an int as does wlen().
 *
 * swap(x) evaluates to x with the high and low halves exchanged.  For 
 *	example, if an int is 16 bits, then swap(0x1234) yields 0x3412.  
 *	Bugs: swap() is a particular instance of rrot(), and therefor has 
 *	the same bugs as rrot().
 *
 */

#define wlen()	   (4 + (1 <<  7 ? 4: 0) + \
			(1 << 11 ? 4: 0) + \
			(1 << 15 ? 4: 0) + \
			(1 << 19 ? 4: 0) + \
			(1 << 23 ? 4: 0) + \
			(1 << 27 ? 4: 0) + \
			(1 << 31 ? 4: 0))

#define biggest()      ((long)(((unsigned)~0) >> 1))
#define smallest()     ~biggest()
#define rrot(x,nbits)  ((x) << wlen() - (nbits) | (unsigned)(x) >> (nbits))
#define swap(x)	       rrot(x, wlen()/2)
/*
 * Homework 4: 5 macros.  October 15, 1990 for Allen Holub, C for professionals.
 * File name: hw4.c
 */

#include <stdio.h>
#include "hw4.h"

/*-----------------------------------------------------------------------*/
/*                     Test the macros in hw4.h                          */

main()
{
	printf("This machine uses %d bits to store an int\n", wlen());

	printf("The largest  value of int on this machine is ");
	printf("%+ld\n", biggest());

	printf("The smallest value of int on this machine is ");
	printf("%+ld\n\n", smallest());

	testout(0);
	testout(-1);
	testout(1);
	testout(biggest());
	testout(smallest());
	testout(0x12345678);
}


/*-----------------------------------------------------------------------*/
/*        Send a number both swapped and right rotated to stdout.        */

testout (number)
int number;	/* a number to be processed */

{
	int bitshift;	/* number of bits to shift right by */

	/*
	 * try rrot() for all of the bit positions in the range:
	 *	-1 <= bitshift <= (bits in an int + 1)
	 */

	for(bitshift = -1; bitshift <= (wlen() + 1); ++bitshift)
	{
		printf("%#x right rotated %d bits ", number, bitshift);
		printf("yields %#x\n", rrot(number, bitshift));
	}
	printf("%#x swapped yields %#x\n", number, swap(number));
	return;
}
This machine uses 32 bits to store an int
The largest  value of int on this machine is +2147483647
The smallest value of int on this machine is -2147483648

0 right rotated -1 bits yields 0
0 right rotated 0 bits yields 0
0 right rotated 1 bits yields 0
0 right rotated 2 bits yields 0
0 right rotated 3 bits yields 0
0 right rotated 4 bits yields 0
0 right rotated 5 bits yields 0
0 right rotated 6 bits yields 0
0 right rotated 7 bits yields 0
0 right rotated 8 bits yields 0
0 right rotated 9 bits yields 0
0 right rotated 10 bits yields 0
0 right rotated 11 bits yields 0
0 right rotated 12 bits yields 0
0 right rotated 13 bits yields 0
0 right rotated 14 bits yields 0
0 right rotated 15 bits yields 0
0 right rotated 16 bits yields 0
0 right rotated 17 bits yields 0
0 right rotated 18 bits yields 0
0 right rotated 19 bits yields 0
0 right rotated 20 bits yields 0
0 right rotated 21 bits yields 0
0 right rotated 22 bits yields 0
0 right rotated 23 bits yields 0
0 right rotated 24 bits yields 0
0 right rotated 25 bits yields 0
0 right rotated 26 bits yields 0
0 right rotated 27 bits yields 0
0 right rotated 28 bits yields 0
0 right rotated 29 bits yields 0
0 right rotated 30 bits yields 0
0 right rotated 31 bits yields 0
0 right rotated 32 bits yields 0
0 right rotated 33 bits yields 0
0 swapped yields 0
0xffffffff right rotated -1 bits yields 0
0xffffffff right rotated 0 bits yields 0xffffffff
0xffffffff right rotated 1 bits yields 0xffffffff
0xffffffff right rotated 2 bits yields 0xffffffff
0xffffffff right rotated 3 bits yields 0xffffffff
0xffffffff right rotated 4 bits yields 0xffffffff
0xffffffff right rotated 5 bits yields 0xffffffff
0xffffffff right rotated 6 bits yields 0xffffffff
0xffffffff right rotated 7 bits yields 0xffffffff
0xffffffff right rotated 8 bits yields 0xffffffff
0xffffffff right rotated 9 bits yields 0xffffffff
0xffffffff right rotated 10 bits yields 0xffffffff
0xffffffff right rotated 11 bits yields 0xffffffff
0xffffffff right rotated 12 bits yields 0xffffffff
0xffffffff right rotated 13 bits yields 0xffffffff
0xffffffff right rotated 14 bits yields 0xffffffff
0xffffffff right rotated 15 bits yields 0xffffffff
0xffffffff right rotated 16 bits yields 0xffffffff
0xffffffff right rotated 17 bits yields 0xffffffff
0xffffffff right rotated 18 bits yields 0xffffffff
0xffffffff right rotated 19 bits yields 0xffffffff
0xffffffff right rotated 20 bits yields 0xffffffff
0xffffffff right rotated 21 bits yields 0xffffffff
0xffffffff right rotated 22 bits yields 0xffffffff
0xffffffff right rotated 23 bits yields 0xffffffff
0xffffffff right rotated 24 bits yields 0xffffffff
0xffffffff right rotated 25 bits yields 0xffffffff
0xffffffff right rotated 26 bits yields 0xffffffff
0xffffffff right rotated 27 bits yields 0xffffffff
0xffffffff right rotated 28 bits yields 0xffffffff
0xffffffff right rotated 29 bits yields 0xffffffff
0xffffffff right rotated 30 bits yields 0xffffffff
0xffffffff right rotated 31 bits yields 0xffffffff
0xffffffff right rotated 32 bits yields 0xffffffff
0xffffffff right rotated 33 bits yields 0
0xffffffff swapped yields 0xffffffff
0x1 right rotated -1 bits yields 0
0x1 right rotated 0 bits yields 0x1
0x1 right rotated 1 bits yields 0x80000000
0x1 right rotated 2 bits yields 0x40000000
0x1 right rotated 3 bits yields 0x20000000
0x1 right rotated 4 bits yields 0x10000000
0x1 right rotated 5 bits yields 0x8000000
0x1 right rotated 6 bits yields 0x4000000
0x1 right rotated 7 bits yields 0x2000000
0x1 right rotated 8 bits yields 0x1000000
0x1 right rotated 9 bits yields 0x800000
0x1 right rotated 10 bits yields 0x400000
0x1 right rotated 11 bits yields 0x200000
0x1 right rotated 12 bits yields 0x100000
0x1 right rotated 13 bits yields 0x80000
0x1 right rotated 14 bits yields 0x40000
0x1 right rotated 15 bits yields 0x20000
0x1 right rotated 16 bits yields 0x10000
0x1 right rotated 17 bits yields 0x8000
0x1 right rotated 18 bits yields 0x4000
0x1 right rotated 19 bits yields 0x2000
0x1 right rotated 20 bits yields 0x1000
0x1 right rotated 21 bits yields 0x800
0x1 right rotated 22 bits yields 0x400
0x1 right rotated 23 bits yields 0x200
0x1 right rotated 24 bits yields 0x100
0x1 right rotated 25 bits yields 0x80
0x1 right rotated 26 bits yields 0x40
0x1 right rotated 27 bits yields 0x20
0x1 right rotated 28 bits yields 0x10
0x1 right rotated 29 bits yields 0x8
0x1 right rotated 30 bits yields 0x4
0x1 right rotated 31 bits yields 0x2
0x1 right rotated 32 bits yields 0x1
0x1 right rotated 33 bits yields 0
0x1 swapped yields 0x10000
0x7fffffff right rotated -1 bits yields 0
0x7fffffff right rotated 0 bits yields 0x7fffffff
0x7fffffff right rotated 1 bits yields 0xbfffffff
0x7fffffff right rotated 2 bits yields 0xdfffffff
0x7fffffff right rotated 3 bits yields 0xefffffff
0x7fffffff right rotated 4 bits yields 0xf7ffffff
0x7fffffff right rotated 5 bits yields 0xfbffffff
0x7fffffff right rotated 6 bits yields 0xfdffffff
0x7fffffff right rotated 7 bits yields 0xfeffffff
0x7fffffff right rotated 8 bits yields 0xff7fffff
0x7fffffff right rotated 9 bits yields 0xffbfffff
0x7fffffff right rotated 10 bits yields 0xffdfffff
0x7fffffff right rotated 11 bits yields 0xffefffff
0x7fffffff right rotated 12 bits yields 0xfff7ffff
0x7fffffff right rotated 13 bits yields 0xfffbffff
0x7fffffff right rotated 14 bits yields 0xfffdffff
0x7fffffff right rotated 15 bits yields 0xfffeffff
0x7fffffff right rotated 16 bits yields 0xffff7fff
0x7fffffff right rotated 17 bits yields 0xffffbfff
0x7fffffff right rotated 18 bits yields 0xffffdfff
0x7fffffff right rotated 19 bits yields 0xffffefff
0x7fffffff right rotated 20 bits yields 0xfffff7ff
0x7fffffff right rotated 21 bits yields 0xfffffbff
0x7fffffff right rotated 22 bits yields 0xfffffdff
0x7fffffff right rotated 23 bits yields 0xfffffeff
0x7fffffff right rotated 24 bits yields 0xffffff7f
0x7fffffff right rotated 25 bits yields 0xffffffbf
0x7fffffff right rotated 26 bits yields 0xffffffdf
0x7fffffff right rotated 27 bits yields 0xffffffef
0x7fffffff right rotated 28 bits yields 0xfffffff7
0x7fffffff right rotated 29 bits yields 0xfffffffb
0x7fffffff right rotated 30 bits yields 0xfffffffd
0x7fffffff right rotated 31 bits yields 0xfffffffe
0x7fffffff right rotated 32 bits yields 0x7fffffff
0x7fffffff right rotated 33 bits yields 0
0x7fffffff swapped yields 0xffff7fff
0x80000000 right rotated -1 bits yields 0
0x80000000 right rotated 0 bits yields 0x80000000
0x80000000 right rotated 1 bits yields 0x40000000
0x80000000 right rotated 2 bits yields 0x20000000
0x80000000 right rotated 3 bits yields 0x10000000
0x80000000 right rotated 4 bits yields 0x8000000
0x80000000 right rotated 5 bits yields 0x4000000
0x80000000 right rotated 6 bits yields 0x2000000
0x80000000 right rotated 7 bits yields 0x1000000
0x80000000 right rotated 8 bits yields 0x800000
0x80000000 right rotated 9 bits yields 0x400000
0x80000000 right rotated 10 bits yields 0x200000
0x80000000 right rotated 11 bits yields 0x100000
0x80000000 right rotated 12 bits yields 0x80000
0x80000000 right rotated 13 bits yields 0x40000
0x80000000 right rotated 14 bits yields 0x20000
0x80000000 right rotated 15 bits yields 0x10000
0x80000000 right rotated 16 bits yields 0x8000
0x80000000 right rotated 17 bits yields 0x4000
0x80000000 right rotated 18 bits yields 0x2000
0x80000000 right rotated 19 bits yields 0x1000
0x80000000 right rotated 20 bits yields 0x800
0x80000000 right rotated 21 bits yields 0x400
0x80000000 right rotated 22 bits yields 0x200
0x80000000 right rotated 23 bits yields 0x100
0x80000000 right rotated 24 bits yields 0x80
0x80000000 right rotated 25 bits yields 0x40
0x80000000 right rotated 26 bits yields 0x20
0x80000000 right rotated 27 bits yields 0x10
0x80000000 right rotated 28 bits yields 0x8
0x80000000 right rotated 29 bits yields 0x4
0x80000000 right rotated 30 bits yields 0x2
0x80000000 right rotated 31 bits yields 0x1
0x80000000 right rotated 32 bits yields 0x80000000
0x80000000 right rotated 33 bits yields 0
0x80000000 swapped yields 0x8000
0x12345678 right rotated -1 bits yields 0
0x12345678 right rotated 0 bits yields 0x12345678
0x12345678 right rotated 1 bits yields 0x91a2b3c
0x12345678 right rotated 2 bits yields 0x48d159e
0x12345678 right rotated 3 bits yields 0x2468acf
0x12345678 right rotated 4 bits yields 0x81234567
0x12345678 right rotated 5 bits yields 0xc091a2b3
0x12345678 right rotated 6 bits yields 0xe048d159
0x12345678 right rotated 7 bits yields 0xf02468ac
0x12345678 right rotated 8 bits yields 0x78123456
0x12345678 right rotated 9 bits yields 0x3c091a2b
0x12345678 right rotated 10 bits yields 0x9e048d15
0x12345678 right rotated 11 bits yields 0xcf02468a
0x12345678 right rotated 12 bits yields 0x67812345
0x12345678 right rotated 13 bits yields 0xb3c091a2
0x12345678 right rotated 14 bits yields 0x59e048d1
0x12345678 right rotated 15 bits yields 0xacf02468
0x12345678 right rotated 16 bits yields 0x56781234
0x12345678 right rotated 17 bits yields 0x2b3c091a
0x12345678 right rotated 18 bits yields 0x159e048d
0x12345678 right rotated 19 bits yields 0x8acf0246
0x12345678 right rotated 20 bits yields 0x45678123
0x12345678 right rotated 21 bits yields 0xa2b3c091
0x12345678 right rotated 22 bits yields 0xd159e048
0x12345678 right rotated 23 bits yields 0x68acf024
0x12345678 right rotated 24 bits yields 0x34567812
0x12345678 right rotated 25 bits yields 0x1a2b3c09
0x12345678 right rotated 26 bits yields 0x8d159e04
0x12345678 right rotated 27 bits yields 0x468acf02
0x12345678 right rotated 28 bits yields 0x23456781
0x12345678 right rotated 29 bits yields 0x91a2b3c0
0x12345678 right rotated 30 bits yields 0x48d159e0
0x12345678 right rotated 31 bits yields 0x2468acf0
0x12345678 right rotated 32 bits yields 0x12345678
0x12345678 right rotated 33 bits yields 0
0x12345678 swapped yields 0x56781234