Question

Edit, compile, and run the following programs on the UNIX shell:

Write a program that takes in six commandline arguments and has four functions (described below) that use bitwise operators.

• The user should enter six space-separated commandline arguments: four characters (any ASCII character) followed by two integers.
  • Anything else should print an error message telling the user what the correct input is and end the program.
  • Convert the commandline input into "unsigned char" and "unsigned int" datatypes.
    • Be careful with looping, as there will be no negative integers.
• Write and use the following four functions:

1. twosComplement: This function should calculate the two's complement of the input parameter.
   • The parameter is one unsigned integer (unsigned int).
   • It should return a signed integer (int), the two's complement of the parameter.
   • Use the one's complement operator (~) to get the one's complement. Add one (1) to that to get the two's complement.
2. charPacker: This function should pack four chars into one integer.
   • The parameters are four unsigned characters.
   • The return is an unsigned integer.
   • Use the left shift operator (<<) and the bitwise inclusive OR operator (|) to pack four 8-bit chars into a 32-bit int.
3. intChopper: This function chops an integer into four chars.
   • The parameters are an unsigned integer (which is the input), and four char pointers (which will hold the outputs).
   • This should be a void function.
   • Use the right-shift operator (>>) and the bitwise AND operator (&) with a mask to separate the 32-bit integer into four 8-bit parts.
   • Save the four 8-bit parts in the four char pointers.
   • In other words, take one 32-bit integer (int) and convert it into four 8-bit characters (char).
4. circleLeft: This function performs a circular left shift of bits.
   • The parameters are two unsigned integers: integer1 and integer2.
   • It should return an unsigned integer.
   • The returned unsigned integer should be integer2 with its bits rotated to the left integer1 times.
   • In other words, when integer1 = 1, one bit on the left end position of integer2 should be removed and stuck on the right end position. If integer1 = 2, the 2 left-most bits of integer2 will be moved to the rightmost position. Etc.
   • You may need to use a mask, left shift operator (<<), right shift operator (>>), bitwise AND (&), and bitwise inclusive OR (|).
   • One possible solution for the circular left shift operation is: circleLeft(n, x) = (x << n) OR (x >> 32-n)

• You will need a makefile for including printbits.h

Here is an outline of the program with the four function prototypes described in the instructions:

#include <stdio.h>
#include <string.h>
#include "printbits.h"

//function prototypes
int twosComplement(unsigned int); 
unsigned int charPacker(unsigned char, unsigned char, unsigned char, unsigned char);
void intChopper(unsigned int, unsigned char*, unsigned char*, unsigned char*, unsigned char*);
unsigned int circleLeft(unsigned int, unsigned int);

int main(int argc, char *argv[]){
//error checking
//function calls
   return 0;
} 

//function definitions

HERE IS THE PRINTBITS.C

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

/* 
   Displays the bit pattern for a 32-bit int
   number: is the 32-bit integer to be displayed
*/
void printbits(unsigned int number){
  //loop counter 
  int i = 0; 
  /*
    A mask is used by bitwise AND to determine 
    if a specific 1 or a 0 is present.
    Masks are used to select some bits 
    (using 1s - which returns 1, if 1, and returns 0, if 0)
    or hide other bits 
    (using 0s - which make everything zero).
    This starts with a 1 at the 31st (leftmost) position,
    followed by 31 zeros.
  */
  unsigned int mask = 0x80000000; 
  
  //loop through the 32 bits
  for(i=31;i>=0;i--) { 
    //printf("i=%i, mask=0x%x",i,mask);
    //determine if a 1 or 0 exists at each bit location
    if(0 != (number & mask)){
      printf("1");
    }
    else{
      printf("0");
    }
    //add a space for easy reading
    if((24==i) || (16==i) || (8==i)){
      printf(" ");
    }
    //shift bits in mask to the right by one bit
    mask = mask >> 1; 
  }//end of for loop
  
    /*
    Display the unsigned integer.  
    %u is the format character for unsigned integers. 
    %d is for signed integers - use if you want to display negative numbers.
    Leave room for 8 extra spaces for hexadecimal numbers.
  */
  printf(" = 0x%.8X = %d \n", number, number);
  
}//end of function

HERE IS THE PRINTBITS.H

void printbits(unsigned int);

HERE IS THE MAKEFILE I MADE

CXX=gcc

CXXFLAGS= -std=c99 -g -Wall -Wshadow -Wpedantic -Wvla -Werror

SOURCES=program.c printbits.c

OBJECTS=$(SOURCES:.c=.o)

EXECUTABLE=./a.out

all: $(SOURCES) $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS)

$(CXX) $(OBJECTS) -o $@

#add -lm after @ to include c math library

clean:

rm -f $(OBJECTS) $(EXECUTABLE)

.c.o:

$(CXX) $(CXXFLAGS) -c -o $@ $

OUTPUT:

./program                                         
ERROR: Please enter the executable name, followed by FOUR characters and then TWO integers on the commandline.
You entered 1 argument(s).

./program A B C D 1 2 3                           
ERROR: Please enter the executable name, followed by FOUR characters and then TWO integers on the commandline.
You entered 8 argument(s).

./program AA B C D 1 2                            
ERROR: Please enter a character for character #1 on the commandline.
You entered 2 characters: AA

./program A B C DDDDD 1 2                         
ERROR: Please enter a character for character #4 on the commandline.
You entered 5 characters: DDDDD

./program A B C D E 2                             
ERROR: You are missing an integer argument.
You entered: E 

./program A B C D 1 F                             
ERROR: You are missing an integer argument.
You entered: F 

./program A B C D 2 1                   

function #1:
Input is unsigned integer:
00000000 00000000 00000000 00000010 = 0x00000002 = 2 
Output is the two's complement of the integer: 
11111111 11111111 11111111 11111110 = 0xFFFFFFFE = -2 

function #2:
Input is four characters:
01000001 = 0x41 = 'A' 
01000010 = 0x42 = 'B' 
01000011 = 0x43 = 'C' 
01000100 = 0x44 = 'D' 
Output is unsigned integer variable in bit format: 
01000001 01000010 01000011 01000100 = 0x41424344 = 1094861636 

function #3:
Input is unsigned integer: 
00000000 00000000 00000000 00000010 = 0x00000002 = 2 
Output is four characters: 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00000010 = 0x02 = '' 

function #4:
Input is unsigned integer: 
00000000 00000000 00000000 00000001 = 0x00000001 = 1 
Rotated 2 bit(s) to the left. 
Output is unsigned integer: 
00000000 00000000 00000000 00000100 = 0x00000004 = 4 

./program w x y z 8 123456789                                 

function #1:
Input is unsigned integer:
00000000 00000000 00000000 00001000 = 0x00000008 = 8 
Output is the two's complement of the integer: 
11111111 11111111 11111111 11111000 = 0xFFFFFFF8 = -8 

function #2:
Input is four characters:
01110111 = 0x77 = 'w' 
01111000 = 0x78 = 'x' 
01111001 = 0x79 = 'y' 
01111010 = 0x7A = 'z' 
Output is packed unsigned integer variable in bit format: 
01110111 01111000 01111001 01111010 = 0x7778797A = 2004384122 

function #3:
Input is an unsigned integer: 
00000000 00000000 00000000 00001000 = 0x00000008 = 8 
Output is four unpacked characters: 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00001000 = 0x08 = '  (note: 8 is backspace)

function #4:
Input is unsigned integer: 
00000111 01011011 11001101 00010101 = 0x075BCD15 = 123456789 
Rotated 8 bit(s) to the left. 
Output is unsigned integer: 
01011011 11001101 00010101 00000111 = 0x5BCD1507 = 1540166919 

./program A B C D 0 0                             

function #1:
Input is unsigned integer:
00000000 00000000 00000000 00000000 = 0x00000000 = 0 
Output is the two's complement of the integer: 
00000000 00000000 00000000 00000000 = 0x00000000 = 0 

function #2:
Input is four characters:
01000001 = 0x41 = 'A' 
01000010 = 0x42 = 'B' 
01000011 = 0x43 = 'C' 
01000100 = 0x44 = 'D' 
Output is packed unsigned integer variable in bit format: 
01000001 01000010 01000011 01000100 = 0x41424344 = 1094861636 

function #3:
Input is an unsigned integer: 
00000000 00000000 00000000 00000000 = 0x00000000 = 0 
Output is four unpacked characters: 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 

function #4:
Input is unsigned integer: 
00000000 00000000 00000000 00000000 = 0x00000000 = 0 
Rotated 0 bit(s) to the left. 
Output is unsigned integer: 
00000000 00000000 00000000 00000000 = 0x00000000 = 0 

./program 1 2 3 4 32 6     

function #1:
Input is unsigned integer:
00000000 00000000 00000000 00100000 = 0x00000020 = 32 
Output is the two's complement of the integer: 
11111111 11111111 11111111 11100000 = 0xFFFFFFE0 = -32 

function #2:
Input is four characters:
00110001 = 0x31 = '1' 
00110010 = 0x32 = '2' 
00110011 = 0x33 = '3' 
00110100 = 0x34 = '4' 
Output is packed unsigned integer variable in bit format: 
00110001 00110010 00110011 00110100 = 0x31323334 = 825373492 

function #3:
Input is an unsigned integer: 
00000000 00000000 00000000 00100000 = 0x00000020 = 32 
Output is four unpacked characters: 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00000000 = 0x00 = '' 
00100000 = 0x20 = ' ' 

function #4:
Input is unsigned integer: 
00000000 00000000 00000000 00000110 = 0x00000006 = 6 
Rotated 32 bit(s) to the left. 
Output is unsigned integer: 
00000000 00000000 00000000 00000110 = 0x00000006 = 6 

./program a b c d 893542945 8      

function #1:
Input is unsigned integer:
00110101 01000010 01100010 00100001 = 0x35426221 = 893542945 
Output is the two's complement of the integer: 
11001010 10111101 10011101 11011111 = 0xCABD9DDF = -893542945 

function #2:
Input is four characters:
01100001 = 0x61 = 'a' 
01100010 = 0x62 = 'b' 
01100011 = 0x63 = 'c' 
01100100 = 0x64 = 'd' 
Output is packed unsigned integer variable in bit format: 
01100001 01100010 01100011 01100100 = 0x61626364 = 1633837924 

function #3:
Input is an unsigned integer: 
00110101 01000010 01100010 00100001 = 0x35426221 = 893542945 
Output is four unpacked characters: 
00110101 = 0x35 = '5' 
01000010 = 0x42 = 'B' 
01100010 = 0x62 = 'b' 
00100001 = 0x21 = '!' 

function #4:
Input is unsigned integer: 
00000000 00000000 00000000 00001000 = 0x00000008 = 8 
Rotated 893542945 bit(s) to the left. 
Output is unsigned integer: 
00000000 00000000 00000000 00010000 = 0x00000010 = 16

Answer 1

This code will work according to your assignment. please go threw it and output.

#include <stdio.h>
#include <stdlib.h>
int TowsComp(unsigned int num)
{
return (~num)+1;
}
void PrintBits(unsigned int num) // print bits
{
int i = 0 ;
int count =0;
for(i=31 ;i>= 0 ;i--)
{
if(count%8 == 0)
printf(" ");
num>>i & 1 ? printf("1"): printf("0");
count++;
}
printf(" = 0x%X = %u",num,num);
printf("\n");
}
void PrintBitsChar(unsigned int num) //print character bits
{
int i = 0 ;
int count =0;
for(i=7 ;i>= 0 ;i--)
{
if(count%8 == 0)
printf(" ");
num>>i & 1 ? printf("1"): printf("0");
count++;
}
printf(" = 0x%X = '%c'",num,num);
printf("\n");
}
unsigned int Pack4Char(unsigned char c1 ,unsigned char c2 ,unsigned char c3 ,unsigned char c4 ) //pack characters in int
{
unsigned int num = 0;
num = num | (c4);
num = num | (c3 << 8);
num = num | (c2 << 16);
num = num | (c1 << 24);

return num;
}
void Upack4Char(unsigned int num) //unpack character from int
{
unsigned char c1 = 0;
unsigned char c2 = 0;
unsigned char c3 = 0;
unsigned char c4 = 0;
c4 = num & 0xFF;
c3 = (num >> 8) & 0xFF;
c2 = (num >> 16) & 0xFF;
c1 = (num >> 24) & 0xFF;
}
unsigned int LelfShift(unsigned int x , unsigned int n) // left shift x by n
{
x = (x << n) | (x>> (32-n));
return x;
}

int main(int argc , char ** argv)
{
if (argc < 2 && argc >= 6) // check arguments are ok or not
{
printf("Usage : ./a.out 4-char 2-numbers ....\n");
return 0;
}

int i =0 , j =0;
unsigned int num[2] ={0};
for(i=1 ; i < argc ;i++) // check arguments and convert in to int
{
if(atoi(argv[i]) == 0)
{
if( i<=4 )
continue;
printf("argument should be 4 latter followed by 2 intiger\n");
return 0;
}
else
{
num[j++] = atoi(argv[i]);
}
}

printf("function #1\n");
printf("Input is unsigned integer\n");
PrintBits(num[0]);
printf("Output is 2's compliment of the integer:\n");
PrintBits(TowsComp(num[0]));

printf("\nfunction #2\n");
printf("Input is four characters\n");
PrintBitsChar(argv[1][0]);
PrintBitsChar(argv[2][0]);
PrintBitsChar(argv[3][0]);
PrintBitsChar(argv[4][0]);
printf("Output is packed unsigned integer variable in bit formate\n");
PrintBits(Pack4Char(argv[1][0],argv[2][0],argv[3][0],argv[4][0]));

printf("\nfunction #3\n");
printf("Input is unsigned integer\n");
PrintBits(num[0]);
printf("Output is four unpacked characters\n");
Upack4Char(num[0]);

printf("\nfunction #4\n");
printf("Input is unsigned integer\n");
PrintBits(num[0]);
printf("Output is unsigned interger\n");
PrintBits(LelfShift(num[0],num[1]));

}

Output: