//********************************************************
//
// Assignment 10 - Linked Lists, Typedef, and Macros
//
// Name: Heather Grothe
//
// Class: C Programming, Spring 2026
//
// Date: April 15, 2026
//
// Description: Program which determines overtime and 
// gross pay for a set of employees with outputs sent 
// to standard output (the screen).
//
// This assignment also adds the employee name, their tax state,
// and calculates the state tax, federal tax, and net pay.   It
// also calculates totals, averages, minimum, and maximum values.
//
// Array and Structure references have all been replaced with
// pointer references to speed up the processing of this code.
// A linked list has been created and deployed to dynamically
// allocate and process employees as needed.
//
// It will also take advantage of the C Preprocessor features,
// in particular with using macros, and will replace all 
// struct type references in the code with a typedef alias
// reference.
//
// Call by Reference design (using pointers)
//
//********************************************************

// necessary header files
#include <stdio.h>
#include <string.h>
#include <ctype.h>   // for char functions
#include <stdlib.h>  // for malloc

// define constants
#define STD_HOURS 40.0
#define OT_RATE 1.5
#define MA_TAX_RATE 0.05
#define NH_TAX_RATE 0.0
#define VT_TAX_RATE 0.06
#define CA_TAX_RATE 0.07
#define DEFAULT_STATE_TAX_RATE 0.08
#define NAME_SIZE 20
#define TAX_STATE_SIZE 3
#define FED_TAX_RATE 0.25
#define FIRST_NAME_SIZE 10
#define LAST_NAME_SIZE 10

// define macros
#define CALC_OT_HOURS(theHours) ((theHours > STD_HOURS) ? theHours - STD_HOURS : 0)
#define CALC_STATE_TAX(thePay,theStateTaxRate) (thePay * theStateTaxRate)
#define CALC_FED_TAX(thePay) (thePay * FED_TAX_RATE)
#define CALC_NET_PAY(thePay,theStateTax,theFedTax) (thePay - (theStateTax + theFedTax))
#define CALC_NORMAL_PAY(theWageRate,theHours,theOvertimeHrs) \
(theWageRate * (theHours - theOvertimeHrs))
#define CALC_OT_PAY(theWageRate,theOvertimeHrs) (theOvertimeHrs * (OT_RATE * theWageRate))
#define CALC_MIN(theValue, currentMin) ((theValue < currentMin) ? theValue : currentMin)
#define CALC_MAX(theValue, currentMax) ((theValue > currentMax) ? theValue : currentMax)

// Define a global structure type to store an employee name
struct name
{
    char firstName[FIRST_NAME_SIZE];
    char lastName [LAST_NAME_SIZE];
};

// Define a global structure type to pass employee data between functions
typedef struct employee
{
    struct name empName;
    char taxState [TAX_STATE_SIZE];
    long int clockNumber;
    float wageRate;
    float hours;
    float overtimeHrs;
    float grossPay;
    float stateTax;
    float fedTax;
    float netPay;
    struct employee * next;
} EMPLOYEE;

// This structure type defines the totals of all floating point items
// so they can be totaled and used also to calculate averages

typedef struct totals
{
    float total_wageRate;
    float total_hours;
    float total_overtimeHrs;
    float total_grossPay;
    float total_stateTax;
    float total_fedTax;
    float total_netPay;
} TOTALS;

// This structure type defines the min and max values of all floating
// point items so they can be display in our final report

typedef struct min_max
{
    float min_wageRate;
    float min_hours;
    float min_overtimeHrs;
    float min_grossPay;
    float min_stateTax;
    float min_fedTax;
    float min_netPay;
    float max_wageRate;
    float max_hours;
    float max_overtimeHrs;
    float max_grossPay;
    float max_stateTax;
    float max_fedTax;
    float max_netPay;
} MIN_MAX;

// Define prototypes here for each function except main
EMPLOYEE * getEmpData (void);
int isEmployeeSize (EMPLOYEE * head_ptr);
void calcOvertimeHrs (EMPLOYEE * head_ptr);
void calcGrossPay (EMPLOYEE * head_ptr);
void printHeader (void);
void printEmp (EMPLOYEE * head_ptr);
void calcStateTax (EMPLOYEE * head_ptr);
void calcFedTax (EMPLOYEE * head_ptr);
void calcNetPay (EMPLOYEE * head_ptr);
void calcEmployeeTotals (EMPLOYEE * head_ptr,
                         TOTALS * emp_totals_ptr);
void calcEmployeeMinMax (EMPLOYEE * head_ptr,
                         MIN_MAX * emp_minMax_ptr);
void printEmpStatistics (TOTALS * emp_totals_ptr, 
                         MIN_MAX * emp_minMax_ptr,
                         int size);

int main ()
{
    EMPLOYEE * head_ptr; // always points to first linked list node

    int theSize; // number of employees processed
    
    // set up structure to store totals and initialize all to zero
    TOTALS employeeTotals  = {0,0,0,0,0,0,0};

    // pointer to the employeeTotals structure
    TOTALS * emp_totals_ptr = &employeeTotals;

    // set up structure to store min and max values and initialize all to zero
    MIN_MAX employeeMinMax = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    
    // pointer to the employeeMinMax structure
    MIN_MAX * emp_minMax_ptr = &employeeMinMax;

    head_ptr = getEmpData ();

    theSize = isEmployeeSize (head_ptr);
    
    if (theSize <= 0) 
    {
        printf("\n\n**** There was no employee input to process ***\n");
    }//if
    else // there are employees to be processed
    {    
    	// Calculate the overtime hours
        calcOvertimeHrs (head_ptr);
                
        // Calculate the weekly gross pay
        calcGrossPay (head_ptr);
                
        // Calculate the state tax                                     
		calcStateTax (head_ptr);
		        
		// Calculate the federal tax                                            
		calcFedTax (head_ptr);
		
		// Calculate the net pay after taxes   
		calcNetPay (head_ptr);
		
		// Keep a running sum of the employee totals
        calcEmployeeTotals (head_ptr, &employeeTotals);
        
        // Keep a running update of the employee minimum and maximum values
        calcEmployeeMinMax (head_ptr, &employeeMinMax);
        
        // Print the column headers
		printHeader();
		
		// print out final information on each employee
        printEmp (head_ptr);
        
        // print the totals and averages for all float items
        printEmpStatistics (&employeeTotals, &employeeMinMax, theSize);
    }//else
    
    printf ("\n\n *** End of Program *** \n");

    return (0); // success

} // main

//**************************************************************
// Function: getEmpData 
//
// Purpose: Obtains input from user: employee name (first an last), 
//          tax state, clock number, hourly wage, and hours worked
//          in a given week.
//
//          Information in stored in a dynamically created linked
//          list for all employees.
//          
// Parameters: void
// 
// Returns:
//
//    head_ptr - a pointer to the beginning of the dynamically
//               created linked list that contains the initial
//               input for each employee.
//  
//**************************************************************
EMPLOYEE * getEmpData (void)
{
    char   answer[80];
    int    more_data = 1;
    char   value;
 
    EMPLOYEE *current_ptr,
             *head_ptr;
 
	// Set up storage for first node
    head_ptr = (EMPLOYEE *) malloc (sizeof(EMPLOYEE));
    current_ptr = head_ptr;
 
    // process while there is still input
	while (more_data)
    {
    	// read in employee first and last name
        printf ("\nEnter employee first name: ");
        scanf ("%s", current_ptr->empName.firstName);
        printf ("\nEnter employee last name: ");
        scanf ("%s", current_ptr->empName.lastName);
 
        // read in employee tax state
		printf ("\nEnter employee two character tax state: ");
        scanf ("%s", current_ptr->taxState);
 
        // read in employee clock number
		printf("\nEnter employee clock number: ");
        scanf("%li", &current_ptr->clockNumber);
 
        // read in employee wage rate
		printf("\nEnter employee hourly wage: ");
        scanf("%f", &current_ptr->wageRate);
 
        // read in employee hours worked
		printf("\nEnter hours worked this week: ");
        scanf("%f", &current_ptr->hours);
 
		// ask user if they would like to add another employee
        printf("\nWould you like to add another employee? (y/n): ");
        scanf("%s", answer);
 
		// check first character for a 'Y' for yes
        // Ask user if they want to add another employee
        if ((value = toupper(answer[0])) != 'Y')
        {
        	// no more employees to process
        	current_ptr->next = (EMPLOYEE *) NULL;
        	more_data = 0; 
        }//if
        else // Yes, another employee
        {
        	// set the next pointer of the current node to point to the new node
        	current_ptr->next = (EMPLOYEE *) malloc (sizeof(EMPLOYEE));
        	// move the current node pointer to the new node
        	current_ptr = current_ptr->next;
        }//else
         
    } // while
 
    return(head_ptr);
    
} // getEmpData

//**************************************************************
// Function: isEmployeeSize
//
// Purpose: Traverses the linked list and keeps a running count
//          on how many employees are currently in our list. 
//
// Parameters:
//
//   head_ptr - pointer to the initial node in our linked list
//
// Returns:
//
//   theSize - the number of employees in our linked list
//
//**************************************************************

int isEmployeeSize (EMPLOYEE * head_ptr)
{
    EMPLOYEE * current_ptr; // pointer to current node
    int theSize;			// number of link list nodes
    						// (i.e., employees)

    theSize = 0;			// initialize

    // assume there is no data if the first node does
    // not have an employee name
    if (head_ptr->empName.firstName[0] != '\0')
    {
    	// traverse through the linked list, keep a running count of nodes
        for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
        {  
            ++theSize; // employee node found, increment
        }//for
    }//if

    return (theSize);  // number of nodes (i.e., employees)

} // isEmployeeSize

//**************************************************************
// Function: printHeader
// 
// Purpose: Prints the initial table header information.
// 
// Parameters: none
// 
// Returns: void
//  
//**************************************************************

void printHeader (void) 
{ 
    printf ("\n\n*** Pay Calculator ***\n");

    printf("\n--------------------------------------------------------------");
    printf("-------------------");
    printf("\nName                Tax  Clock# Wage   Hours  OT   Gross ");
    printf("  State  Fed      Net");
    printf("\n                   State                           Pay   ");
    printf("  Tax    Tax      Pay");
    printf("\n--------------------------------------------------------------");
    printf("-------------------");

} // printHeader

//**************************************************************
// Function: printEmp
// 
// Purpose: Prints out all the information for each employee
//          in a nice and orderly table format.
// 
// Parameters: 
//
//   head_ptr - pointer to the beginning of our linked list
// 
// Returns: void
//  
//**************************************************************

void printEmp (EMPLOYEE * head_ptr)
{
	
	// Used to format the employee name
    char name [FIRST_NAME_SIZE + LAST_NAME_SIZE + 1];
    
    EMPLOYEE * current_ptr; // pointer to current node

    
    // traverse through the linked list to process each employee
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
    	//format employee name
        strcpy (name, current_ptr->empName.firstName);
        strcat (name, " "); // add a space between first and last names
        strcat (name, current_ptr->empName.lastName);
    
        // Print out current employee in the current linked list node
        printf("\n%-20.20s %-2.2s  %06li %5.2f  %4.1f  %4.1f %7.2f %6.2f %7.2f %8.2f",
               name, current_ptr->taxState, current_ptr->clockNumber, 
               current_ptr->wageRate, current_ptr->hours,
               current_ptr->overtimeHrs, current_ptr->grossPay, 
               current_ptr->stateTax, current_ptr->fedTax, 
               current_ptr->netPay);
    }//for
          
} // printEmp

//**************************************************************
// Function: printEmpStatistics
// 
// Purpose: Prints out the summary totals and averages of all 
//          floating point value items for all employees
//          that have been processed.  It also prints
//          out the min and max values.
// 
// Parameters: 
//
//   emp_totals_ptr - pointer to a structure containing a running total 
//                    of all employee floating point items
//
//   emp_minMax_ptr - pointer to a structure containing
//                    the minimum and maximum values of all
//                    employee floating point items
//
//   tjeSize - the total number of employees processed, used 
//             to check for zero or negative divide condition.
// 
// Returns: void
//
//**************************************************************

void printEmpStatistics (TOTALS  * emp_totals_ptr,
                         MIN_MAX * emp_minMax_ptr,
                         int theSize)
{
	
	// print a separator line
    printf("\n--------------------------------------------------------------");
    printf("-------------------");
    
    // print the totals for all the floating point items
    printf("\nTotals:                         %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
           emp_totals_ptr->total_wageRate,
           emp_totals_ptr->total_hours,
           emp_totals_ptr->total_overtimeHrs,
           emp_totals_ptr->total_grossPay,
           emp_totals_ptr->total_stateTax,
           emp_totals_ptr->total_fedTax,
           emp_totals_ptr->total_netPay);
    
    // make sure you don't divide by zero or a negative number
    if (theSize > 0)       
    {
    	// print the averages for all the floating point items
        printf("\nAverages:                       %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
               emp_totals_ptr->total_wageRate/theSize,
               emp_totals_ptr->total_hours/theSize,
               emp_totals_ptr->total_overtimeHrs/theSize,
               emp_totals_ptr->total_grossPay/theSize,
               emp_totals_ptr->total_stateTax/theSize,
               emp_totals_ptr->total_fedTax/theSize,
               emp_totals_ptr->total_netPay/theSize);
    }//if
    
    // print the min and max values for each item
    
    printf("\nMinimum:                        %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
           emp_minMax_ptr->min_wageRate,
           emp_minMax_ptr->min_hours,
           emp_minMax_ptr->min_overtimeHrs,
           emp_minMax_ptr->min_grossPay,
           emp_minMax_ptr->min_stateTax,
           emp_minMax_ptr->min_fedTax,
           emp_minMax_ptr->min_netPay);
    
    printf("\nMaximum:                        %5.2f %5.1f %5.1f %7.2f %6.2f %7.2f %8.2f",
           emp_minMax_ptr->max_wageRate,
           emp_minMax_ptr->max_hours,
           emp_minMax_ptr->max_overtimeHrs,
           emp_minMax_ptr->max_grossPay,
           emp_minMax_ptr->max_stateTax,
           emp_minMax_ptr->max_fedTax,
           emp_minMax_ptr->max_netPay);
           
    // print out the total employees process
    printf ("\n\nThe total employees processed was: %i\n", theSize);

}  // printEmpStatistics

//**************************************************************
// Function: calcOvertimeHrs
//
// Purpose: Calculates the overtime hours worked by an employee
//          in a given week for each employee.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the overtime hours gets updated by reference)
//
//**************************************************************

void calcOvertimeHrs (EMPLOYEE * head_ptr)
{
    EMPLOYEE * current_ptr; // pointer to current node

    // traverse through the linked list to calculate overtime hours
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {  
        current_ptr->overtimeHrs = CALC_OT_HOURS(current_ptr->hours);
    }//for

} // calcOvertimeHrs

//**************************************************************
// Function: calcGrossPay
//
// Purpose: Calculates the gross pay based on the the normal pay
//          and any overtime pay for a given week for each
//          employee.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the gross pay gets updated by reference)
//
//**************************************************************

void calcGrossPay (EMPLOYEE * head_ptr)
{
    float theNormalPay; // normal pay without any overtime hours
    float theOvertimePay; // overtime pay

    EMPLOYEE * current_ptr; // pointer to current node

    // traverse through the linked list to calculate gross pay
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        // calculate normal pay and any overtime pay
        theNormalPay = CALC_NORMAL_PAY(current_ptr->wageRate,
                                       current_ptr->hours,
                                       current_ptr->overtimeHrs);

        theOvertimePay = CALC_OT_PAY(current_ptr->wageRate,
                                     current_ptr->overtimeHrs);
                                     
        // calculate gross pay for employee as normalPay + any overtime pay
        current_ptr->grossPay = theNormalPay + theOvertimePay;
    }//for

} // calcGrossPay

//**************************************************************
// Function: calcStateTax
//
// Purpose: Calculates the State Tax owed based on gross pay
//          for each employee.  State tax rate is based on the 
//          the designated tax state based on where the
//          employee is actually performing the work.  Each
//          state decides their tax rate.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the state tax gets updated by reference)
//
//**************************************************************

void calcStateTax (EMPLOYEE * head_ptr)
{
    EMPLOYEE * current_ptr; // pointer to current node

    // traverse through the linked list to calculate the state tax
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
    	// Make sure tax state is all uppercase
        if (islower(current_ptr->taxState[0]))
        {
            current_ptr->taxState[0] = toupper(current_ptr->taxState[0]);
        }//if
        
        if (islower(current_ptr->taxState[1]))
        {
            current_ptr->taxState[1] = toupper(current_ptr->taxState[1]);
        }//if
        
        // calculate state tax based on where employee resides
        if (strcmp(current_ptr->taxState, "MA") == 0)
        {
            current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay,
                                                   MA_TAX_RATE);
        	
        }//if
        else if (strcmp(current_ptr->taxState, "VT") == 0)
        {
            current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay,
                                                   VT_TAX_RATE);
        	
        }//else if
        else if (strcmp(current_ptr->taxState, "NH") == 0)
        {
        	current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay,
                                                   NH_TAX_RATE);
        	
        }//else if
        else if (strcmp(current_ptr->taxState, "CA") == 0)
        {
            current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay,
                                                   CA_TAX_RATE);
        }//else if
        else
        {
            current_ptr->stateTax = CALC_STATE_TAX(current_ptr->grossPay,
                                                   DEFAULT_STATE_TAX_RATE);
        }//else
    }//for
       
} // calcStateTax

//**************************************************************
// Function: calcFedTax
//
// Purpose: Calculates the Federal Tax owed based on the gross 
//          pay for each employee
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the federal tax gets updated by reference)
//
//**************************************************************

void calcFedTax (EMPLOYEE * head_ptr)
{
    EMPLOYEE * current_ptr; // pointer to current node

    // traverse through the linked list to calculate the federal tax
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
        current_ptr->fedTax = CALC_FED_TAX(current_ptr->grossPay);
    }//for
    
} // calcFedTax

//**************************************************************
// Function: calcNetPay
//
// Purpose: Calculates the net pay as the gross pay minus any
//          state and federal taxes owed for each employee.
//          Essentially, their "take home" pay.
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//
// Returns: void (the net pay gets updated by reference)
//
//**************************************************************

void calcNetPay (EMPLOYEE * head_ptr)
{
    EMPLOYEE * current_ptr; // pointer to current node

	// traverse through the linked list to calculate the net pay
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
    	// calculate the net pay
        current_ptr->netPay = CALC_NET_PAY(current_ptr->grossPay,
                                           current_ptr->stateTax,
                                           current_ptr->fedTax);
    } //for
    
} // calcNetPay

//**************************************************************
// Function: calcEmployeeTotals
//
// Purpose: Performs a running total (sum) of each employee
//          floating point member item stored in our linked list 
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//   emp_totals_ptr - pointer to a structure containing the 
//                    running totals of each floating point
//                    member for all employees in our linked
//                    list
//
// Returns: 
//
//   void (the employeeTotals structure gets updated by reference)
//
//**************************************************************

void calcEmployeeTotals (EMPLOYEE * head_ptr,
                         TOTALS   * emp_totals_ptr)
{
    EMPLOYEE * current_ptr; // pointer to current node

	// traverse through the linked list to calculate a running 
    // sum of each employee floating point member item
    for (current_ptr = head_ptr; current_ptr; current_ptr = current_ptr->next)
    {
    	// add current employee data to our running totals
        emp_totals_ptr->total_wageRate += current_ptr->wageRate;
        emp_totals_ptr->total_hours += current_ptr->hours;
        emp_totals_ptr->total_overtimeHrs += current_ptr->overtimeHrs;
        emp_totals_ptr->total_grossPay += current_ptr->grossPay;
        emp_totals_ptr->total_stateTax += current_ptr->stateTax;
        emp_totals_ptr->total_fedTax += current_ptr->fedTax;
        emp_totals_ptr->total_netPay += current_ptr->netPay;
    }//for
    
} // calcEmployeeTotals

//**************************************************************
// Function: calcEmployeeMinMax
//
// Purpose: Accepts various floating point values from an
//          employee and adds to a running update of min
//          and max values
//
// Parameters:
//
//   head_ptr - pointer to the beginning of our linked list
//   emp_minMax_ptr - pointer to the min/max structure
//
// Returns: 
//
//   void (employeeMinMax structure updated by reference)
//
//**************************************************************

void calcEmployeeMinMax (EMPLOYEE * head_ptr,
                         MIN_MAX  * emp_minMax_ptr)
{
    EMPLOYEE * current_ptr; // pointer to current node
   
    current_ptr = head_ptr; // set to first employee, our initial linked list node
    
    // set the min to the first employee members
    emp_minMax_ptr->min_wageRate = current_ptr->wageRate; 
    emp_minMax_ptr->min_hours = current_ptr->hours;
    emp_minMax_ptr->min_overtimeHrs = current_ptr->overtimeHrs; 
    emp_minMax_ptr->min_grossPay = current_ptr->grossPay;
    emp_minMax_ptr->min_stateTax = current_ptr->stateTax;
    emp_minMax_ptr->min_fedTax = current_ptr->fedTax;
    emp_minMax_ptr->min_netPay = current_ptr->netPay;
        
    // set the max to the first employee members
    emp_minMax_ptr->max_wageRate = current_ptr->wageRate; 
    emp_minMax_ptr->max_hours = current_ptr->hours;
    emp_minMax_ptr->max_overtimeHrs = current_ptr->overtimeHrs;
    emp_minMax_ptr->max_grossPay = current_ptr->grossPay;
    emp_minMax_ptr->max_stateTax = current_ptr->stateTax;
    emp_minMax_ptr->max_fedTax = current_ptr->fedTax;
    emp_minMax_ptr->max_netPay = current_ptr->netPay;

    // ******************************************************
    // move to the next employee
    //
    // if this the only employee in our linked list
    // current_ptr will be NULL and will drop out the 
    // the for loop below, otherwise, the second employee
    // and rest of the employees (if any) will be processed
    // ******************************************************
    current_ptr = current_ptr->next;
    
    // traverse the linked list
    // compare the rest of the employees to each other for min and max
    for (; current_ptr; current_ptr = current_ptr->next) 
    {
        // check if current Wage Rate is the new min and/or max
        emp_minMax_ptr->min_wageRate = 
           CALC_MIN(current_ptr->wageRate, emp_minMax_ptr->min_wageRate);
        emp_minMax_ptr->max_wageRate = 
           CALC_MAX(current_ptr->wageRate, emp_minMax_ptr->max_wageRate);
        
        // check if current Hours is the new min and/or max
        emp_minMax_ptr->min_hours = 
           CALC_MIN(current_ptr->hours, emp_minMax_ptr->min_hours);
        emp_minMax_ptr->max_hours = 
           CALC_MAX(current_ptr->hours, emp_minMax_ptr->max_hours);       
        
        // check if current Overtime Hours is the new min and/or max
        emp_minMax_ptr->min_overtimeHrs = 
           CALC_MIN(current_ptr->overtimeHrs, emp_minMax_ptr->min_overtimeHrs);
        emp_minMax_ptr->max_overtimeHrs = 
           CALC_MAX(current_ptr->overtimeHrs, emp_minMax_ptr->max_overtimeHrs);
        
        // check if current Gross Pay is the new min and/or max
        emp_minMax_ptr->min_grossPay = 
           CALC_MIN(current_ptr->grossPay, emp_minMax_ptr->min_grossPay);
        emp_minMax_ptr->max_grossPay = 
           CALC_MAX(current_ptr->grossPay, emp_minMax_ptr->max_grossPay);
        
        // check if current State Tax is the new min and/or max
        emp_minMax_ptr->min_stateTax = 
           CALC_MIN(current_ptr->stateTax, emp_minMax_ptr->min_stateTax);
        emp_minMax_ptr->max_stateTax = 
           CALC_MAX(current_ptr->stateTax, emp_minMax_ptr->max_stateTax);
        
        // check if current Federal Tax is the new min and/or max
        emp_minMax_ptr->min_fedTax = 
           CALC_MIN(current_ptr->fedTax, emp_minMax_ptr->min_fedTax);
        emp_minMax_ptr->max_fedTax = 
           CALC_MAX(current_ptr->fedTax, emp_minMax_ptr->max_fedTax);
        
        // check if current Net Pay is the new min and/or max
        emp_minMax_ptr->min_netPay = 
           CALC_MIN(current_ptr->netPay, emp_minMax_ptr->min_netPay);
        emp_minMax_ptr->max_netPay = 
           CALC_MAX(current_ptr->netPay, emp_minMax_ptr->max_netPay);
    }//for
    
} // calcEmployeeMinMax