CMSC 106

Project #7

Spring 2001

Due date: Monday, May 14

1. Purpose

In this project you will write a program using structures and structures which contain other structures as members, arrays of structures, and functions with structure parameters, using both call-by-value and call-by-reference.

For this project you will be managing a bakery. You will have a list of ingredients you have in stock and a list of recipes you make with those ingredients. When an order comes in, you must determine if you have enough of all the ingredients required in order to fill that order. If you do not have enough of all of the ingredients, you must tell which ones have insufficient quantity.

2. Project description

As you read this section, you may also want to refer to the ``Sample output'' section below.

2.1 Program input

There will be three input files.

1. The first input file will be a list of ingredients you have in stock. Each line will contain the name of that ingredient followed by the quantity you have on hand of that ingredient. The name of the ingredient will be a single word (no spaces) but can contain uppercase, lowercase and punctuation characters. The quantity will be a positive real number followed by a single character abreviation for the units. For the units, the c or C will be used to indicate cups, t will be used to indicate teaspoons, T will be used to indicate tablespoons and Q or q will be used to indicate quarts. The last line of this file will have the word ``done'' alone on the line. An example of one line of this file would be:

   
   flour   18.5 c
   

   This would mean you have 18 and a half cups of flour on hand. The items on this line will be separated by white space (one or more blanks) and there could be blanks at the beginning or end of the line. Any alternative spelling of the name of an ingredient should be considered a completely different ingredient, but the name with a different pattern of capitalization should be considered to be the same item.

2. The second input file will be a list of recipes you cook at your bakery. Each recipe will have a name which it on a line by itself. This name should again be considered not case sensitive. The lines following the name will contain the list of ingredients needed for that recipe in the same format as the list of stock ingredients contained in the first input file. The list of ingredients for this one recipe will end by having the word ``done'' alone on the line after the last ingredient. The last line of this input file will contain the word ``lastrecipe'' on a line by itself to indicate that there are no more recipes. One recipe in the file could look like the following:

   
   bread
   flour 3 c
   yeast 2 t
   milk 1.2 c
   sugar 2 T
   done
   

   This would mean that in order to make 1 order of bread you need to have 3 cups of flour, 1.2 cups of milk and 2 tablespoons of sugar, and 2 teaspoons of yeast. The items on each line will be separated by whitespace (one or more blanks) and there could be spaces before or after the line.

3. The third input file will be a customer order being placed with bakery. It should contain a list of recipes (hopefully) from the second input file which will then be made using the ingredients from the first input file. Your goal here will be to determine if you have the recipes for the items requested and if you have enough of each of the ingredients to fill the order. The first line of this file will contain the name of the customer. The name can contain spaces, but won't be longer than 80 characters. The format of the rest of this file will be a quantity followed by a name of a recipe. The quantity will be a positive integer telling how many of that recipe the customer would like you to prepare. The list of items requested will end with the end of file marker. You do not need to worry about the possibility of the same recipe (item) being requested more than one time in this list, you may assme your customer is too organized to allow that to happen.

2.2 Processing and output

1. The first input file will be a list of ingredients you have in stock. Before starting to process the first input file, you need to print a line that says the exact phrase PROCESSING STOCK INGREDIENTS to the screen. You will need to read each ingredient and store it into your (stock) list of ingredients if it is valid according to the definitions that follow. If the name is written into the file using any uppercase characters, you should convert it so that it is all lower case characters to make later comparisons easier.
   • If that item is not already in your stored list of ingredients, it should be added to the list in such a way that the stored (stock) ingredient list remains in alphabetical order at all times. The ``alphabetical'' order will actually be ASCII order when you consider the numeric and punctuation characters that can be included. All alphabetical characters should be changed to lowercase, but you do not need to worry about where non-alphabetical characters appear in the ASCII order - just allow the strcmp to determine the ordering of these names.
   • If that item already appears in the list and the units of measurement agree, this new quantity should be added to the quantity already stored in your list but the item should only appear in your stored list only once.
   • If that item already appears in the list but the units of measurement do not agree, the second occurrence of this item should be discarded with an error message saying the name of the ingredient in double quotes and the exact word discarded.
   When you are finished processing this first input file (even if nothing was printed to the screen during the processing, you should print one line containing the exact phrase DONE PROCESSING STOCK INGREDIENTS.

2. The second input file will be a list of recipes you cook at your bakery. Before starting to process this second input file, you need to print a line that says the exact phrase PROCESSING RECIPE LIST to the screen. The name of the recipe needs to be read from the input file. The list of ingredients should be read in and put in alphabetical order like the first input file's list. All of the same rules and error messages should be used when reading this list of ingredients as were used when reading the stock ingredients. The items on each line will be separated by whitespace (one or more blanks) and there could be spaces before or after the line. If the name of the recipe or the name of the ingredient has any uppercase characters, convert them to their lowercase equivalent to make later comparisons easier. After you read the recipe, you need to be sure it is a valid recipe according to the rules below before storing it in your (cookbook) list of recipes. The list of recipes should just remain in the order read from the input file. They do not need to be alphabetized.
   • If the name of the recipe has already been read in this input file, you must discard the recipe (as if it wasn't in the file at all) and print an error message which includes the name of the recipe in quotation marks followed by the exact phrase already exists!.
   • If the name of the recipe is fine (unique), but the name of an ingredient does not exist in your list created from the first input file, you must also discard the recipe and print an error message which includes the name of the ingredient in quotation marks followed by the exact phrase not available.
   • If the unit of measure is not the same as what appears in the list created by the first input file for that ingredient, you will also not be able to bake that item and the recipe should be discarded. An error message should print with the exact phrase incorrect unit for followed by the name of the ingredient where the name of the ingredient is in quotation marks.
   • One and only one error message should appear if a recipe is being discarded. If more than one of these error messages is applicable to the current recipe, only the first in this list should be printed. If more than one ingredient/unit is invalid in the same recipe, it should only print a message for the (alphabetically) first invalid ingredient/unit in the list of that recipe. Any additional invalid ingredients/units for the same recipe should be ignored as the whole recipe is thrown away.
   • Regardless of which of the above reasons caused the recipe to be discarded, there should be one more line of output with a message containing the name of the recipe in double quotes followed by the exact word ``discarded''.
   When you are done processing the information of the second input file, you must print one line containing the exact phrase DONE PROCESSING RECIPE LIST even if nothing was printed to the screen during the processing of this input file.

3. The third list will be a customer order being placed with the bakery. Before starting to process this third input file you must print a line with the exact phrase PROCESSING CUSTOMER ORDER. You must first read and store the customer's name to be printed in the final communication to that customer.
   • If any one of the recipes requested is not one you have in your list of recipes from the second file, you must print that you can not fill the order stating the exact phrase can't fill order - don't make followed by the name of the recipe you do not make at this bakery. The name of the recipe requested must be contained in quotation marks. If any of the recipes in the list are things you do not make at your bakery, you should print this message once and only once and only for the first invalid recipe that appears in the order list as read from the third input file.
   • If all of the recipes listed in the third input file are things you make at your bakery, then you can check to be sure you would have sufficient ingredients to make all of these recipes. If the order requires more than the quantity you would have on hand for any one ingredient, again you must state that you can not fill the order using the exact phrase can't fill order - don't have enough followed by the name of the ingredient of which you have insufficient quantity. The name of the ingredient for which there is insufficient quantity must be contained in quotation marks. This message should appear for the first ingredient which causes the stock to go below 0 (more to use than you have). The order of the recipes requested is as determined from the order of the lines in the third input file. The order of the ingredients for any of those recipes is the ``alphabetical'' order in which they were placed as the recipes were read from the second input file. Even if more than one ingredient goes to negative, only one error message should be printed, and it must be the first ingredient (alphabetically) that goes negative assuming the recipes are being made in the order of the third input file.
   • If you print any message that states you can not fill the order, you must then make a closing statement that you regret that you can not take this order including the exact word sorry followed by the name of the customer. You should then do no more output.
   • If all of the recipes listed in the third input file are things you make at your bakery and you have sufficient quantity to make those recipes, you should then print the recipes you will be using to fill this order. The format should be the name of the recipe on one line by iself followed by the alphabetized list of ingredients for one batch of that recipe. The recipes should each be followed by a dashed line of 10 dashes to act as a delimeter.
   • If you do bake all of the requested items and you have sufficient quantities of all of the required ingredients for those items, you should then print a message stating the exact phrase ``ORDER TO BE FILLED for'' followed by the name of the customer. This one line will be followed by the list of what you will be baking. This list should be one per line with the quantity followed by the name of the recipe (in the order read from the third input file). This list should be followed by a line containing the exact phrase ``REMAINING IN STOCK'' followed by the list and quantities (amount and unit) of ingredients you would have in stock after filling this order. The floating point values should be printed using two decimal places beyond the decimal point. Other than that, the format of each line should be the same as the first input file. This ingredient stock list should be in the alphabetical (ASCII) order you created as you read the first input file, but the quantities should be changed to reflect that this order was filled.

2.3 Program limits and assumptions

• Each ingredient or recipe name, valid or invalid, will be no longer than 20 characters.

• The quantities of ingredients will be positive real numbers (possibly with a fractional portion).

• The quantities of recipes (items) in the customer order list will be positive integers (no fractional portion).

• There will not be more than 30 valid ingredients in the first input file.

• There will not be more than 10 valid recipes in the second input file.

• Each recipe will contain no more than 7 ingredients. (We do not have very accomplished cooks working at this bakery.)

• No order will have over 5 different items in the list (but it could have multiple quantities of each of the items listed).

• The customer name will not be more than 80 characters in length.

• The input files will all be as described above without extra or missing items on any line.

3. Project requirements

All your C programs in this course should be written in ANSI C, which means they must compile and run correctly with cc -std1 -trapuv on the OIT UNIX Class Cluster. You will lose credit if your program generates any warning messages when it is compiled. Prototypes must appear for all functions used, listed at the top of the program file.

You may use any ANSI C language features we have discussed in the course so far, plus anything we will discuss between now and the end of the semester, with the following exceptions:

• neither the goto nor the continue statement may be used, and the break statement may not be used in any loop.

• the exit() library function may not be used at all, and at most one return statement may be used in any function, including main.

• no global variables may be used.

• no functions whose names start with mem can be used

• no single function, including the main function, can be longer than 30 lines of executable statement (where each of the statements in a compound statement count individually and a statement that has subsidiary statements must count each subsidiary as one).

Using any of these disallowed C features will result in losing credit.

Your program must define three structure types, as described below, which must be named exactly as shown. Your structures must contain the data items specified, but can have additional data fields besides these if you want.

Ingredient:

• a name of the ingredient - character string
• an amount - a float
• a unit - a single character

Recipe:

• a name of the recipe - a character string
• a number of ingredients in this recipe - an integer
• a list of Ingredients - an Ingredient array

Order:

• a name of the customer - character string
• a number of recipes being requested by that customer - an int
• a list of recipes - a Recipe array (with some way to keep track of quantity of each recipe)

Your program must contain (and use) at least eight separate structure functions. A structure function either has a structure as a parameter, a structure as its return value, or has a pointer to a structure as a parameter. Your program must have at least one such function for each of the three required structures. To get more practice using functions with structures, and to make your program easier to develop and test, it is highly recommended that you write more than eight structure functions (that you write as many as possible). At least two of your structure functions must use call-by-value for their structure parameter(s) or must have a structure as their return value. At least two of the other functions must use call-by-reference for their structures, so they must have pointers to structures as parameters, and they access the structures through the pointers.

If your program doesn't contain, and call, at least eight structure functions, of the types indicated, it will be graded as if it does not work on the primary input- even if its output is correct.

You may also write functions which don't operate on structures, as you like.

Here are some suggestions for possible structure functions; feel free to use others:

• A function which reads in a single Ingredient.
• A function which reads in the Ingredient array.
• A function which prints a single Ingredient.
• A function which prints the Ingredient array.
• A function which reads in a single Recipe.
• A function which reads in the Recipe array.
• A function which prints a single Recipe.
• A function which prints the array of Recipes.
• A function which finds an Ingredient in the list.
• A function which finds the place the Ingredient should go if it isn't already in the list.
• A function which inserts the Ingredient into the list.
• A function which finds a Recipe in the list.
• A function which reads the Order.
• A function which determines if the Ingredient is valid in file 1.
• A function which determines if the Recipe is valid in file 2.
• A function which determines if the requested Recipe in file 3 is available.

Your program must have a comment near the top which contains your name, login ID, student ID, your section number, your TA's name, and an original description of the action and operation of the program. Do not put your alias in this comment! In addition, you must have a comment before each function, explaining its action and operation. Your program should be written using good programming style and formatting, as discussed in class and throughout your textbook. For this project, style is considered to consist of:

• adequate descriptive comments throughout (in addition to the comments mentioned above), to describe what your program is doing and how

• neat and proper indentation and formatting, including correctly aligning braces using any of the bracing styles illustrated in your textbook

• writing clear and readable code

• use of meaningful descriptive variable and parameter names

• use of symbolic constants for all ``special'' values which don't change and which are used in more than one place in your code, and for all array dimensions

• avoiding disallowed C language features and global variables as discussed above

• using prototypes for all functions with descriptions of the purpose of each function either by the prototype or the function definition

• using character constants (e.g., 'A'), rather than the characters' numeric ASCII values anywhere that specific character values are needed.

• avoiding multiple return statements in any function

4. Developing your program

You may want to skip this section at first, read the rest of the project, and come back to study it carefully when you are about to begin writing your program.

The more you write functions to perform various manipulations on structures, the easier your code becomes to test. You can use either call-by-value or call-by-reference for structure functions, but you have to have the indicated number of functions of each type. It is really recommended you use functions for each separate, discrete operation to be performed on any structure.

Do not use a global structure variable or array, like your book does in its example in Chapter 16! You will lose substantial credit if you use global variables in your project. Use the structure program to be posted as an example of one with structures and functions which doesn't use global variables.

4.1 Possible development steps

It is extremely useful to first develop your program to work for simple cases of input. When it works perfectly for these, you can add code to handle the more complex situations one at a time. For this project, this might mean first developing your program for a simple input data file with just one valid command. You can create several such files, with one command of each type, making sure your results are correct for each. When you have thoroughly tested the different situations which can occur for the various commands and the results for all of them are fine, you can create a larger input file with several commands of different types.

This outline is a suggestion only; you do not have to follow it. There are many ways to develop any program. However, whatever steps you do choose in developing your project, you should be certain to write small parts of your program at a time and test each one to verify that it works before going on!

1. To get more practice with structures, it might be a good idea to first define just the Ingredient structure type. It contains several fields, but is much simpler than the other structures, which each contain an array of structures. You might also write a function which initializes a variable of this type of structure, using either call-by-value (returning a new structure with appropriate values in its fields) or call-by-reference. Declare a variable of this type, and call this function on it. Store some new values into the appropriate fields of your structure and print the values in all its fields, to verify you are manipulating structures correctly.

2. Create functions to read and print the information from each of the three input files. Make sure everything is being read and printed correctly before you try to do any comparisons or processing of orders.

3. Create several simple input files
   • one with only 1 ingredient, one receipe and only one item in the order list
   • modify the recipe's contents to test the different error messages from that file
   • modify that one item in the order list to test each of the error messages from that file
   • add a second ingredient and test all of the relavent combinations

4. Go back and read the project description above to identify the other cases and situations which have to be handled. Add code for each of these, compiling and checking after each one.

5. Lastly, thoroughly check your entire program after finishing it before submitting it.

4.2 Finding compilation errors

If you get an error from the first line of your first structure function, which identifies a syntax error right after the name of the structure type, you probably have declared the structure type after this function which uses it. All structure type definitions must precede the first use of a variable or parameter of that structure type.

Here are several other common compilation errors having to do with structures produced by the cc compiler on our class machines and what they mean:

• Invalid member declaration

  Structure fields cannot be initialized in a structure type definition. See your class notes or text for the proper way to declare a structure variable with an initializer.

• ``X'' has a struct type, but occurs in a context that requires a pointer

  (where X is the name of a structure variable)

  You are using the -> operator with something which is a structure, not a pointer to a structure. The -> operator only operates upon a pointer to a structure. Carefully draw a picture of your structure variables, and look at how the statement with the error is referencing them.

• ``X'' has a pointer type, but occurs in a context that requires a union or struct

  (where X is the name of a pointer variable)

  This is the opposite of the above problem. You are using the . operator with something which is a pointer to a structure, not a structure.

• Identifier expected but not found

  You are using the . operator directly in front of an array subscript (i.e., x.[y]). The . operator selects a field of a structure, so it must be followed by a field name, not a subscript. Perhaps you are trying to refer to an element within an array field, but you forgot the array field name after the . and before the subscript.

• ``X'' is not an lvalue, but occurs in a context that requires one

  (where X is the name of an array variable)

  You are trying to assign something to the name of an array. Perhaps you are trying to copy one character string to another, but you have to use strcpy since you cannot assign arrays.

• ``X'' is of type ``int'', and may not be converted to ``unnamed struct''

  (where X is the name of a variable being used as a function's return value)

  You are probably trying to return an int from a function whose return type is a structure, not a number.

• ``X'' is of type ``unnamed struct'', and may not be converted to ``int''

  (where X is the name of a structure variable)

  This is the opposite of the above problem. You are probably trying to return a structure from a function whose return type is int, not a structure.

• ``X'' is of type ``unnamed struct'', and may not be converted to ``pointer to unnamed struct''

  (where X is the name of a structure variable)

  You are trying to pass a structure to a call-by-reference structure function, which is expecting an argument which is a pointer to a structure.

• ``&X'' is of type ``pointer to unnamed struct'', and may not be converted to ``unnamed struct''

  (where X is the name of a structure variable)

  This is the opposite of the above problem. You are trying to pass a pointer to a structure to a call-by-value structure function, which is expecting an argument which is a structure, not a pointer to a structure.

4.3 Program debugging

1. Add lots of debug printf statements if your code isn't working, to find out where! You need to know this before you can find out why the problem is occurring.

2. Draw lots of pictures of your structure types to trace exactly where things are in memory.

3. If after you have tried these techniques, and tested each of your functions, you still can't figure out why your program doesn't work, bring a printout to our office hours, and we can help you learn how to track the problem down.

4.4 Helpful hints

Frequently save backup copies of your program under different names or in different subdirectories, so even if you inadvertently delete your file or change things which you realize you shouldn't have, it's easy to recover a recent version.

5. Academic integrity statement

Any evidence of unauthorized use of computer accounts or cooperation on projects will be submitted to the Student Honor Council, which could result in an XF for the course, suspension, or expulsion from the University. Projects are to be written INDIVIDUALLY. For academic honesty purposes, projects are to be considered comparable to a take-home exam. Any cooperation or exchange of ideas which would be prohibited on an exam is also prohibited on a project assignment, and WILL BE REPORTED to the Honor Council.

VIOLATIONS OF ACADEMIC HONESTY INCLUDE:

1. failing to do all or any of the work on a project by yourself, other than assistance from the instructional staff.

2. using any ideas or any part of another student's project, or copying any other individual's work in any way.

3. giving any parts or ideas from your project, including test data, to another student.

4. having programs on an open account or on a PC that other students can access.

5. transferring any part of a project to or from another student or individual by any means, electronic or otherwise.

IT IS THE RESPONSIBILITY, UNDER THE UNIVERSITY HONOR POLICY, OF ANY STUDENT WHO LEARNS OF AN INCIDENT OF ACADEMIC DISHONESTY TO REPORT IT TO THEIR INSTRUCTOR.

6. Submitting your project

Your project must be electronically submitted by the date above, to avoid losing credit as described on the syllabus. No projects more than two days late will be accepted for credit without prior permission or a valid medical excuse, as described on your syllabus. Only the project which you electronically submit, according to the procedures provided, can be graded; it is your responsibility to test your program and verify that it works properly before submitting. Lost passwords or other system problems do not constitute valid justifications for late projects, so do not put off working on your program or wait to submit it at the last minute!

Turn in your assignment using the ``submit'' program as before, except using ``7'' for the project number. You are to submit only the .c file containing your source code, not the executable version of your program! If your program is in a file named ``bakery.c'', submit would be run as submit 7 bakery.c.

Before you submit your project, you must exactly follow the specific submission checklist in the ``Testing projects before submitting'' handout separately posted by your instructor!

7. Sample output

Be sure to test your program against a variety of inputs, so you are sure it works in all circumstances!

The primary input and output files will be posted in your instructor's class posting account- do not try to type them in yourself! The primary output consists of all the data values in the entire output shown in the posted file. Note that this primary input does not exercise a number of conditions discussed above which your program should work for in order to earn credit for the secondary inputs.