Defines interface of field.c functions (do not modify) More...

#include <stdbool.h>

Functions
bool	fieldFits (int value, int width, bool isSigned)

int	getBit (int value, int index)

int	getField (int value, int hi, int lo, bool isSigned)

int	setBit (int oldValue, int index, int newValue)

int	setField (int oldValue, int hi, int lo, int newValue)

Detailed Description

This file defines the interface to a C file field.c that you will complete. You will learn how to use the C language operators for binary and (&), binary or (|), and binary not (~). You will also use the C language bit shift operators (<< and >>).

Binary and (&) will be used to extract the value of a bit and to set a bit to 0. This relies on the fact that the binary and (&) of a value and 1 results in the original value. Binary and (&) of a value and 0 results in 0. Binary or (|) is use to set a bit to 1. This relies on the the fact that binary or (|) of 1 and anything results in a 1.

You will create masks. A mask is a bit pattern that contains 0's and 1's in appropriate places so when the binary and/or operation is performed, the result has extracted/modified the bits of interest. In the following examples B stands for bits of interest while x stands for a bit that is not of interest. Note that, in general, the bits of interest need not be consecutive. In this code, we will be dealing with consecutive sets of bits.


  value:    xxxBBBBxxxxx  value: xxxBBBBxxxxx   value: xxxBBBBxxxxx
  mask:     000111100000  mask:  111000011111   mask:  000111100000
  -------   ------------         ------------          ------------
  and(&)    000BBBB0000   and(&) xxx0000xxxxx   or(|)  xxx1111xxxxx
  result:   isolate field        clear field           set field

You may create masks on the fly using C code, or you may pre compute masks and store them in an array and just use the one you need. Note the mask for clearing bits is the binary not (~) of the mask for extracting bits.

Bit positions are numbered from 31 to 0 with 0 being the least significant bit. The bit position corresponds to the power of 2 in the binary representation.

As an example of how the fields interface is useful consider the IEEE half precision floating point representation. In the IEEE half precision floating point representation, 16 bits are used to represent a floating point number. This is shown in the following table where S represents the sign, E represents bits for the exponent, and F represents bits for the fraction.

bit position	31..16	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0
meaning	not used	S	E	E	E	E	E	F	F	F	F	F	F	F	F	F	F

To extract fields from the value, you would make calls like:


   int sign = getField(value, 15, 15, false);
   int exp  = getField(value, 14, 10, false);
   int frac = getField(value,  9,  0, false);

In the following methods, hi and lo are NOT guaranteed to be ordered! So getField(value, 5, 10, false) and getField(value, 10, 5, false) must both produce identical results.

Author: Fritz Sieker

Function Documentation

bool fieldFits	(	int	value,
		int	width,
		bool	isSigned
	)

Determine if a value will fit in a specified field

Parameters

value	the source value
width	the number of bits holding the value
isSigned	false means the field is unsigned, true means the field is signed.

Returns: false if the field does NOT fit. Return true if the value fits.

Todo:: Implement in field.c based on documentation contained in field.h

int getBit	(	int	value,
		int	index
	)

Extract the bit at a specified bit position

Parameters

value	the source value or bit pattern
index	the bit position

Returns: the value of the bit (0 or 1)

Todo:: Implement in field.c based on documentation contained in field.h

int getField	(	int	value,
		int	hi,
		int	lo,
		bool	isSigned
	)

Extract the field (possibly signed) between bits hi and lo (inclusive).

Parameters

value	the source value or bit pattern
hi	the bit position of one end of the field
lo	the bit position of the other end of the field
isSigned	false means the field is unsigned, true means the field is signed

Returns: The value of the field. Sanity check example: if the field is three bits wide and unsigned, the result will be a value between 0 and 7, regardless of the actual position of the bits in value. If the value is signed, the result will be between -4 and 3.

Todo:: Implement in field.c based on documentation contained in field.h

int setBit	(	int	oldValue,
		int	index,
		int	newValue
	)

Change the bit of oldValue at index to the newValue, leaving the other bits unchanged.

Parameters

oldValue	the original value
index	the bit position to change
newValue	the new value to put in the bit (0 or 1)

Returns: the value after replacing only the index position by newValue

Todo:: Implement in field.c based on documentation contained in field.h

int setField	(	int	oldValue,
		int	hi,
		int	lo,
		int	newValue
	)

Change the bits of oldValue between hi and lo to the newValue, leaving the other bits unchanged.

Parameters

oldValue	the original value
hi	the bit position of one end of the field
lo	the bit position of the other end of the field
newValue	the new value to put in the field (use lower bits)

Returns: the value after replacing only the hi to low bits inclusive by newValue

Todo:: Implement in field.c based on documentation contained in field.h

Functions

Detailed Description

Function Documentation