Ira Pohl CMPS 012A: Homework 3

C Course Homework

Homework 3 - Structured Programming: Character Processing

Things You Will Need to Learn

Functions(Chapter 4)
Character Processing (Chapter 5)
This includes but is not limited to an understanding of how C represents and stores characters with the use of the ASCII code. The book has a complete ASCII chart in Appendix E. You should also know about the built-in functions available for your use in the C library ctype.h .
File Redirection

Program Description

You will write a program to process a text file. Your program will consist of a series a functions to perform various tasks on the text file. You program will use getchar() and putchar() to do any necessary input/output to perform these tasks.

The first function will output each line of text with a line number at the beginning of each line. For instance, given the input


     This is the first line.
     This is the second line.

this function would produce the output


     1 This is the first line.
     2 This is the second line.

The function prototype for this function is


     void line_num()   /* Takes standard input or a redirected file and */
                       /* outputs to standard output the lines of the   */
                       /* input prepended with line numbers.            */

The second function will count how many times a given letter appears in the input. It will return that count as well as print the count to the output. The function has a parameter which tells the function which letter it should look for in the input. The se should be case insensitive. For example, if the letter passed to the function is "y", then the function will count how many times the letter "y" or "Y" occurs in the input. Given the input, You may wonder why the sky is blue. Then again, maybe you
will wonder
Why ask why?

a call to the function with the letter "y" as the parameter would produce the output

whereas a call to the function with the letter "i" as the parameter would produce the output

The function prototype for this function should be


     int cnt_let(char c)   /* Takes standard input or a redirected file */
                           /* and counts the letter c (both upper and   */
                           /* lower case).                              */

The third function will be used to encrypt your file. It will use the system random number generator to perform the encryption. It will take readable text (text that is unencrypted) and transform it to encrypted text. The standard encryption would be adding the character to the random number and then using "%" to mod it back t alphabetic value. This will be further explained in class. You should definitely check out this sample program which uses the random number generator to do character encryption. Make sure you understand this program before attempting to incorporate this concept into homework #3. Note: You should only encrypt alphabetic characters. In other words the code given in the sample code is correct (although you may choose an alternative encryption formula). Your main task to get this part of the program to work is to create a function and generate the proper interface with the main program. This really is the way secret messages are protected. (An optional exercise is to write the corresponding decryption routine.)

The main() function will be written to test these routines. The special character "$" will signal which routine is to be invoked (called). The head of the input file will have a "$" followed by either a "1", a "2", a "3", or a "4". Seeing "$1" in the input means do line numbers (main hands calls the first function). Seeing "$2<character>" means count how often <character> appears in the input (main calls the second function). Seeing "$3" means encrypt the input (main calls the third function). Finally, seeing "$4" means do nothing (main ignores the input until the next "$" is encountered). So, encountering "$2b" in the input means to count all "b"'s (and "B"'s) until the next "$" is seen. The main program should terminate when it encounters EOF (end-of-file) in the input so you have to check for it in your program. If you're giving input to your program using the keyboard, you have to type "Ctrl-d" to signal EOF. If you're redirecting a inputfile into your program, you don't have to do anything special.

For a sample input and a sample output, click here . Recall redirection occurs when you type


     % myprog < testfile

This uses the contents of testfile as the input to myporg. Use the editor to create a testfile which tests your program comprehensively. Do not just rely on the sample testfile given in the example.

Grading

Style -- 2 points total

proper comments 1 point
- Name, class, date, instruct program description, and useful in-line comments.
proper indentation, use of whitespace, and overall appearance 1 point

Correctness -- 6 points total

Correct outer loop 1 point. Reads in characters one at a time until EOF is reached.
Correct usage of getchar() 1 point. The program should have no calls to scanf(). Only getchar() should be used to do input.
Correct implementation of "$1" function 1 point.
- The prototype should be: void line_num(); The function call should only be executed when the current character is a '1' and the previous character was a '$'.
- The function should have some sort of counting variable which keeps track of line numbers.
- As soon as the function body is entered, the first line number should be printed.
  Then the function body should contain a loop which reads in characters one at a time until EOF is reached or '$' is reached.
- While the loop is running, characters from the input should be echoed to the screen, and when a '\n' is encountered, the counting variable should be incremented and the next line number printed.
Correct implementation of "$2" function 1 point
- The prototype should be: int cnt_let(char c);
- The function call should only be executed when the current character is a '2' and the previous character was a '$'.
  Just before the function is called, the character following the '2' should be read in and passed to the function as an argument.
- The function body should contain a loop which reads in characters one at a time until EOF is reached or '$' is reached.
- The function should have some sort of a counting variable which is incremented every time current character is equal to the character which was passed to the function. This comparison should be case insensitive.
- When done, the function should return the counting variable. The value of the counting variable can either be printed to the output from within the function or from main() after the function is called.
Correct implementation of "$3" function 1 point
- The prototype should be: void <name>(void);
- The function call should only be executed when the current character is a '3' and the previous character was a '$'.
- The function body should contain a loop which reads in characters one at a time until EOF is reached or '$' is reached.
- To do the encryption, the program should have one call to srand (either at the beginning of main() or at the beginning of the encryption function) and calls to rand() when a character
  encryption occurs. A character should only be encrypted if it is alphabetic. A uppercase character should be encrypted to another uppercase character, and a lowercase character should be
  encrypted to another lowercase character. See the sample program on the web for the format.
Correct implementation of "$4" 1 point
- This may or may not be a function depending on the student's preference.
- Either way, the code which implements "$4" should only execute when the current character is a'4' and the previous character was a '$'.
- The code should consist of a loop which reads in characters (and does nothing with them) one at a time until EOF is reached or '$' is reached.

Program execution -- 2 points total

Running "% a.out < HW3.input1" should produce output similar to that listed in "HW3.output1". This tests "$1". Exact output is not important, except that after "$1" is encountered the line numbers begin at 1, and for every '\n' the line number is incremented and printed out.
Running "% a.out < HW3.input2" should produce output like in "HW3.output2". The numbers (letter counts) in the output should be exact. This tests "$2".
Running "% a.out < HW3.input3" should produce output similar to that listed in "HW3.output3". This tests "$3". Exact output is not important, except that uppercase letters in the input should be encrypted to uppercase letters in the output, lowercase letters should be encrypted to lowercase letters, and any non-alphabetic characters are not encrypted (left as is).
Running "% a.out < HW3.input4" should produce no output. This tests "$4".
Running "% a.out < HW3.input5" should produce output similar to that listed in "HW3.output5" with the same constraints as listed above for each specific case. This test the combination of the directives above ("$1", "$2", "$3", and "$4").

Deductions

Deduct 3 points if the program does not compile.
(use "gcc <filename.c>")

Hints

Use the C library ctype.h . It contains functions which will make some of the character processing easier.
Make sure you have an idea of how the program should flow. Take a look at the example Then try to write your program from the top down:
- Write pseudocode.
- Write main(). Test it.
- Add function 1 to the program. Test it.
- Add function 2 to the program. Test it.
- Add function 3 to the program. Test it.
In other words, start with the easier stuff, and make sure you test your program in increments, so that you can catch any errors in logic before they might become lost among all the code.
For help with using rand() and character encryption, check out this mini-program . You can copy this program to your account, compile it, and run it, to see how it works.
Think of your input file as a stream of characters starting off with a file pointer to the first character in the file. (In this program you may assume the first character is a '$'.) Every time your program does a getchar(), the character pointed to by the file pointer is returned, and then the file pointer is advanced to the next character in the input stream. Note that getchar() reads every character in the file one at a time (including newline characters, '\n').

Let's suppose our input file contains:


              $1Hi
              world!
              (EOF)

You can think of this file as a stream of characters with the file pointer starting ot the first character ('$'):


              $  1  H  i  '\n'  w  o  r  l  d  !  '\n'  (EOF)
              ^

where the carat (^) represents the file pointer.

Now, suppose we have a program which simply reads a file one character at a time using getchar():


              #include <stdio.h>

              int main(void)
              {
                 char c;

                 c = getchar();
                 while ( c != )
                    c = getchar();

                 return 0;
              }

When getchar() gets called the first time, c is assigned the value '$', and the file pointer is advanced to the '1'. The first getchar() call in the while loop assigns c the value '1' and advances the file pointer to 'H'. Here are some of the iterations and the corresponding values of c after getchar() is called:


              $  1  H  i  '\n'  w  o  r  l  d  !  '\n'  (EOF)
              ^
                   getchar() assigns '$' to c and advances file pointer

              $  1  H  i  '\n'  w  o  r  l  d  !  '\n'  (EOF)
                 ^
                   getchar() assigns '1' to c and advances file pointer

              $  1  H  i  '\n'  w  o  r  l  d  !  '\n'  (EOF)
                    ^
                   getchar() assigns 'H' to c and advances file pointer

                        .
                        .
                        .

              $  1  H  i  '\n'  w  o  r  l  d  !  '\n'  (EOF)
                                               ^
                   getchar() assigns '!' to c and advances file pointer

              $  1  H  i  '\n'  w  o  r  l  d  !  '\n'  (EOF)
                                                   ^
                   getchar() assigns '\n' to c and advances file pointer

              $  1  H  i  '\n'  w  o  r  l  d  !  '\n'  (EOF)
                                                          ^
                   getchar() assigns EOF to c

                   program terminates

FAQs

Star Solutions for Character Processing Program

Derek Miyasaki - Good solution with a character look-ahead in the line_num function to prevent a line number from being printed when "\n$" is encountered in the input.
Robin Hirsch-Jacobson - Useful comments; clean and easy to read. Also solves the line number problem when "\n$" is encountered using a great unique approach.