Week05 Lab Exercise

CS4023 Week05 Lab Exercise
Lab Objective: We commented at the end of last week’s lab that our copyFile program was
inflexible in that the “from” and “to” files were hard coded into the source code. We will
now remedy this. We will also use the lab to look at the software development process of C
or C++ .
Here's a quick summary of the tasks:
1. Create a directory (folder) for this week’s work
2. Copy the C source code copyFile.c from last time into your directory (this week’s)
3. Write a more useful version of the copyFile program so that it can accept “command
line arguments”
4. Modify this program now so that it can perform a very weak type of encryption. In
doing this you will learn about
a. the way characters (chars) are represented internally in C
b. strcmp, how strings (of characters) are compared in C
c. breaking your program into multiple files which is vital for maintaining large
programming projects
5. Once the program is working according to the specifications given below you should
submit it for marking using Sulis
In Detail
You can create this week’s lab directory with
mkdir ~/cs4023/labs/week05
This assumes that you already had created the directory ~/cs4023/labs/ from last time.
A little shortcut that instructs mkdir to make any necessary “parent” directories along the
way is
mkdir -p ~/cs4023/labs/week05
Now change your working directory to this since all of our compiling, etc. will be done in this
directory. See last week for how to change working directory.
To start off we need our copyFile.c source file from last time. If you did not succeed in
getting last week’s lab completed you can use the readFile.c code instead that is uploaded in
the assignment Spec. In the first case, you will issue the following cp command:
cp ../week05/copyFile.c .
If you are going the other way, mention in your blogs what steps did you take to bring the
file in Sulis (‘readFile.c’) to a file in your linux machine.
When a C program is entered as a process on the OS’s ready queue the first point of
execution is the function called main(). In last week’s lab this function did not take any
arguments. Now we are going to change this so that arguments specified on the command
line can be passed into our program. (This is akin to calling a function with different
parameters.) To do this you will change
int main()
to
int main(int argc, char* argv[])
The first argument, argc indicates how many arguments our program was called with –
including the program’s name itself. This might seem a bit odd but there are good reasons
for it. The second argument to main, is a block of memory that allows us to access the
command-line arguments of our program. It is called argv where the ’v’ at the end is to
denote a vector (or sequential block) of data. We can access a particular argument that our
program was called with by means of argv[i]. Remember that C programmers waste nothing
so they start counting from 0 instead of 1. In argv[0] we can gain access to the program
name. So, if we gave a command from the shell prompt:
copyFile here there
then the character string “copyFile” is associated with argv[0]. Further, if we gave this
command from the shell prompt:
../week05/copyFile here there
then the string of characters associated with argv[0] would be “../week05/copyFile”.
argc tells us how many arguments; argv gives a way of accessing each of those arguments.
Remember that the name of the program running counts as an argument and can be
accessed in argv[0].
In order to open the first file for reading you will need to modify your first fopen() system
call so that it uses the first argument given to on the command line. (We call the command
itself the zeroth argument.)
The first part of today’s lab is to write this copyFile program. Once you think you have it
working you must test it with the diff command. Assuming that you had already created
a file here if you gave the command:
copyFile here there
then you would ensure that the source and destination files are identical with:
diff here there
diff operates silently so if the files are identical, you will see no output from diff.
The second task for today is to modify this program so that, if the -f flag is given as the first
command-line argument a very simple form of encryption called flipping is performed. If a
file is copied in flip format, then all numerical characters and upper and lower case letters
should be replaced in the destination by their flip.
So, what is the flip of a character? If we take the lower-case letter ’e’, the fifth letter of the
alphabet as an example, then when it is flipped it should be replaced by the fifth letter of
the alphabet from the end of the lower-case alphabet. Likewise, for an upper-case letter or
a number. For your reference I have given you a “before and after” file. They can be found
in Sulis Assignment Spec and were generated as follows:
copyFile -f sample sample.flip
and are repeated here.
The contents of sample:
abcdefghijklmnopqrstuvwxyz;
ABCDEFGHIJKLMNOPQRSTUVWXYZ,
0123456789.
The contents of sample.flip:
zyxwvutsrqponmlkjihgfedcba;
ZYXWVUTSRQPONMLKJIHGFEDCBA,
9876543210.
Notice how the punctuation characters at the end of each line made it through safely
So how – finally! – do we implement in code the flip? What you could do would be to have a
giant, mega, 62-way “if” statement (26 lowercase + 26 uppercase + 10 digits.) along the lines
of:
if (c == ’a’)
putc(’z’, destfile);
elsif (c == ’b’)
putc(’y’, destfile);
:
// ouch!
The two clinching reasons for not doing things this way is that it is very error-prone and not
very maintainable (for making changes later). Most of all though our professional pride
should drive us to search for something more elegant. We can do something a lot more
elegant and more compact once we realise how C deals with characters. In all computer
languages everything must be represented ultimately as a series of 0s and 1s. In C, the
letters ’a’ to ’z’ are encoded consecutively. This means that whatever 8-bit pattern is used to
represent the letter ’d’, when viewed as an integer, the letter ’e’ can be viewed as an
integer one larger. As we will see below it is irrelevant what the value of the integer
corresponding to any of them are: all we need to know is that they occur consecutively.
The previous was put in bold so that you would remember it.
Likewise, the letters ’A’ to ’Z’ occur consecutively but strangely they are not consecutive to
their lower-case counterparts. The digits ’0’ to ’9’ are also consecutive but, again, they are
isolated form the other two “blocks” by other characters – punctuation, I think.
What this means is that we could write a function to translate any lower-case character to
its corresponding upper-case as follows:
char toUpper(char c)
{
if (’a’ <= c && c <= ’z’) // a valid lowercase
return c-’a’ + ’A’; // c-’a’ is offset
return c; // wasn’t LC so leave alone
}
You will need to write a function flipChar() that takes a single character as argument and
does something like the toUpper() function above. Because there are three different cases
to consider (lower-case, upper-case and digits) you will need to distinguish between the
three cases and act accordingly.
In order to keep things simple, in this assignment we will treat anything outside the ranges
0-9, a-z and
A-Z as being non-alphabetic and let them pass through unchanged.
At a very high level the program will operate very similarly to your copyFile program in the
first part of the lab. The difference here is that each character that is read is either flipped,
or not, depending on the first command-line argument. If it is -f then flipping is in effect –
and the origin and destination file command-line arguments are in argv[2] and argv[3]. A
nice way to achieve all this is to
• Test firstly at the beginning of your program if flipping is in effect and storing the
result in an integer that will be either 0 (false) or 1 (true):
int flipping = (strcmp(argv[1], "-f") == 0);
We compare the string pointed to by argv[1] against the string “-f” using the C
function strcmp(). If they are equal, then strcmp() returns 0; in any other case what
is returned is the subtraction of the characters where they first differ, so you can tell
which string is larger.
Before you can call a function in C you must give the compiler fair warning. To
“declare” the strcmp() function to the compiler all you have to do is to have it read
the declarations in the string.h file. This is done by putting at the top of your
program:
#include <string.h>
• Now, when you want to write a character to the destination within your main while
loop you ask if flipping is in effect and you execute the following
if (flipping) // same as: if (flipping == 1)
 putc(flipChar(c), destfile);
else
 putc(c, destfile);
There is one final task to this week’s lab. While it may appear gratuitous or contrived in this
small case it is important enough to introduce this concept early in the series of lab
exercises you will do. This is the idea of decomposing programs into multiple source files. All
serious software is made up of code coming from multiple files and/or libraries so it is a
good habit to get into now.
In our case here you should put your flipChar() function and any other functions that you
might write for the assignment in a C file called utils.c. This file will be compiled separately
into object code, utils.o, and then linked together with a separately compiled copyFile.o
object file as shown below. Whenever you make a change to your flipChar() function you
will need to recompile utils.c with:
gcc -c utils.c
and then relink the two object files with:
gcc copyFile.o utils.o -o copyFile
Similarly, changing any of the source code of copyFile.c necessitates a recompilation of this
with:
gcc -c copyFile.c
and re-linking of the two object files.
You will call the flipChar() function from copyFile.c so when this is being compiled the
compiler had better be pre-warned of its existence. You do this by putting all the utilsrelated declarations in a file called utils.h and giving the compiler knowledge of its contents
by putting
#include "utils.h"
just below all of the other #include directives that you have in your copyFile.c file. I have
written this for you, and it is available with all the others.
copyFile
gcc copyFile.o utils.o -o copyFile
copyFile.o utils.o
gcc -c copyFile.c gcc -c utils.c
copyFile.c utils.h utils.c
Submit all files on Sulis under Assignments there be an opening for this.