CS140 -- Lab 4

CS140 -- Data Structures
Brad Vander Zanden
This lab is conceptually difficult and students have struggled to complete it in the past because they put it off until a couple days before it was due and then could not complete it. Start early!
We have not yet covered unions in class and will not do so until next Tuesday. You should get started on this lab by implementing linked lists using either stock transactions only, or options transactions only. Once you get the lab working with one or the other, you can add unions to accommodate the other type of transaction.

This lab will give you practice using linked lists and unions. Files that you will need:

Executables for the answers are in the directory /home/bvz/cs140/labs/lab4. As usual, if you have questions about how these programs should work, try these.
Some helpful functions for the broker program can be found in parse.c.
A sample input file for linenum can be found in brad and a sample input file for broker can be found in transaction_data. You should make up your own sample data as well.
broker.h contains the beginnings of your broker.h file.
You will need to include fields.h.
You must write your own linked lists for this lab and they must be doubly-linked lists with sentinel nodes. You may not use Dr. Plank's dlist library for this assignment.

Part 1: linenum

Write a program called linenum that takes a filename and an arbitrary number of words from the command line and then prints the line numbers from the file on which each of these strings appears. You must use the fields library to read each line of input. You should use a dynamically allocated array of lists to keep track of the list of line numbers for each word. Each line of output should consist of a word and then the line numbers on which it appears. Line numbers should not be duplicated. The words should be printed in the order in which they appear on the command line. For example, if the file brad contains the lines:

ice cream is nice
but chocolate ice
cream is dandy

then the command:

<UNIX> linenum brad cream nice ice Nice

should produce the output:

cream 1 3
nice 1
ice 1 2
Nice

The words on the command line may be duplicated (e.g., ice may appear twice) but it is okay to only print that word once in your output. My executable will duplicate the output for that word, which is also acceptable.

Testing Suggestions

I have provided one test file in the lab4 directory, linenum_test1 to test your program. However, you should test your program for boundary-type conditions and command line issues, such as:

An empty file
An extremely large file
Files that have lines with duplicate words
Command lines with duplicate words
Files that have lines with duplicate words but the words are in different case (e.g., nice, Nice, and NICE).
Command lines with duplicate words but the words are in different case
Command lines with too few arguments
Filenames that do not exist

Part 2: broker

Write a program called broker that reads stock and option transactions from a file, groups them by customer, and then prints out a report showing the total dollar amount of transactions for each customer and a list of that customer's transactions, printed in the order in which they were read. The customers will be printed in descending order based on the total value of their transactions.

input

The input will consist of records of two types:

stock transaction: A stock transaction has the format:
```
stock ticker_symbol num_shares price_per_share dividend_amt customer_name
```
stock is a keyword that identifies the type of transaction. ticker_symbol is a 3-5 character string that is used by traders as a shorthand symbol for the stock's name, num_shares is an integer expressing the number of shares involved in the transaction, and price_per_share is a floating point number denoting the price paid for each share. The dividend_amt is the amount of dividends the company pays on each share of stock. Finally the customer's name is a character string consisting of one or more words. The fields library will represent these words as separate fields so you will have to concatenate them together and put a single space between each word. A sample stock line might be:
```
stock ibm 200 83.50 2.50 Brad Vander Zanden
```
option transaction: A single option gives you the right to buy 100 shares of a stock at a specific price, called the strike price, until a specific date, called the expiration date. An option record will have the following format:
```
option ticker_symbol num_options price_per_share strike_price expiration_date customer_name
```
option option is a keyword indicating the transaction type. ticker_symbol is a character string of 3-5 characters representing the option's trading symbol. num_options is an integer denoting the number of options purchased and price_per_share is a floating point number denoting the price paid for each share covered by an option. Since each option represents 100 shares the total transaction cost is determined by the following equation:
```
total transaction cost = price_per_share * 100 * num_options
```
The strike price is a floating point number and the expiration date has the format mm yyyy where mm is an integer between 1 and 12 and yyyy is a year. Finally the customer name is similar to the customer name for a stock. A sample input line for an option might appear as follows:
```
option oibm 3 5.50 85 12 2004 Brad Vander Zanden
```
This line says that Brad Vander Zanden has bought 3 calls on ibm at $5.50 a share. The call gives the customer the right to purchase the stock at $85.00 a share until December, 2004.

Writing the Program

Your program should create a dlist that contains customer records. Each customer record will contain the customer's name, the customer's total transaction costs and a dlist that consists of all of the customer's transactions. You will need to define two structs, one for a customer record and one for a transaction record. A transaction record needs to store two types of transactions, stock transactions and option transactions. Stock and option transactions share some common information but each transaction also has some unique fields. Hence you will need to employ a union within your transaction struct that can represent the alternative information required for each type of transaction. Your solution must employ a union.

Once you have read all the transactions and organized them by customer, you should create a new dlist that will contain the customers sorted in descending order by total transaction cost. You will need to iterate through your initial customer list and add each customer to your new dlist using insertion sort.

Printing the Report

The final thing you need to do is print the report. Each customer should start with a line that lists the customer's name and total transaction costs. The customer's name should be left justified in a field of 20 characters and the total transaction costs should be right-justified in a field that allows two decimal points. The customer line should be followed by indented lines that list the customer's transactions, one per line. Transaction lines should be indented by 4 spaces. Stock transaction lines should have fields in the following order and should be separated by one space:

The keyword stock left-justified in a field of 6 characters.
The stock's ticker symbol right justified in a five character field.
The stock's total cost, right justified in an 9 character field, of which two of the characters are devoted to the decimal point.
The stock's dividend total, right justified in an 8 character field, of which two of the characters are devoted to the decimal point. The dividend total is computed as:
```
     dividend total = num_shares * dividend_amt
     
```

Option transaction lines should have fields in the following order and should be separated by one space:

The keyword option.
The option's ticker symbol right justified in a five character field.
The option's total cost, right justified in an 8 character field, of which two of the characters are devoted to the decimal point.
The option's strike price, right justified in a 6 character field, of which two of the characters are devoted to the decimal point.
The option's expiration date, in the form mm/yyyy.

If you have questions about how the output should appear, consult the sample executable.

Helpful Functions and Files

parse.c defines two functions named parse_stock_fields and parse_option_fields that will 1) type check the fields for a stock or option transaction, 2) print appropriate error messages for any bad data, 3) convert the fields denoting numeric values to the appropriate type and store them in the named parameters, and 4) return an error code to denote whether or not the line of input is valid.
- You need to pass pointers to the numeric variables you want filled in order for these functions to work properly.
- These functions type check the ticker symbol field but do not save it for you. They also do not create the customer name for you. You will have to write the code to create the customer name yourself.
- These functions do all the error checking for each line in the transaction file so you do not need to do any further error checking on these lines.
- The return values are 0 if no error is detected and 1 if an error is detected.
- If an error is detected you should discard the input line.
broker.h provides extern declarations for the two functions named above. You must complete this file with declarations for your customer and transaction structs.

What to Submit

Submit two source files named linenum.c and broker.c respectively and a header file named broker.h.