Thanks Shabir for looking at it


Code:
#ifndef GJC_UTILITY_H
#define GJC_UTILITY_H

/* Function prototypes. */
void readRestOfLine();
void systemInit(GJCType* menu);
int loadData(GJCType* menu, char* menuFile, char* submenuFile);
void systemFree(GJCType* menu);
int checkNumInput(char input[]);
#endif

Code:
#include "gjc.h"
#include "gjc_options.h"
#include "gjc_utility.h"

/****************************************************************************
* Function readRestOfLine() is used for buffer clearing. Source: 
* https://inside.cs.rmit.edu.au/~sdb/teaching/C-Prog/CourseDocuments/
* FrequentlyAskedQuestions/
****************************************************************************/
void readRestOfLine()
{
   int c;

   /* Read until the end of the line or end-of-file. */   
   while ((c = fgetc(stdin)) != '\n' && c != EOF)
      ;

   /* Clear the error and end-of-file flags. */
   clearerr(stdin);
}


/****************************************************************************
* Initialises the system to a safe empty state.
****************************************************************************/
void systemInit(GJCType* menu)
{
  

    
   /* declaration of for loop variables*/
   int i;
   
   /* remember to malloc all pointers in structs*/
   
   menu->headCategory = NULL;
   
   menu->numCategories = 0;
   
   
   
   
   
   
}


/****************************************************************************
* Loads all data into the system.
***********************
*****************************************************/
int loadData(GJCType* menu, char* menuFile, char* submenuFile)
{
   /*pointer for malloc*/
   CategoryType *newCat, *currentCat, *prevCat ;
   ItemType     *newItem, *currentItem, *prevItem;
   
   

   /*declaration of variables*/
   int CountNoLines = 0;
   char temp[LINE_LENGTH];
   char tempf2[LINE_LENGTH];
   
   /* variables for tokenizer for menu file*/
   char *catID;
   char *catType;
   char *catName;
   char *catDescription;
   char *line;
   
   int count;
   
   /* variables for sub menu*/
   char *itemIDPtr;
   char *itemNamePtr;
   char *itemDescriptionPtr;
   char *dollarPtr;
   char *centsPtr;
   
   float dollarInt;
   float centInt;
   
   /* declare file pointers to files*/
   FILE *f1;
   FILE *f2;
   
   
   /* opening the menu and submenu for reading*/
   f1 = fopen(menuFile, "r");
   f2 = fopen(submenuFile, "r");
   
   /* check to see if the filuse exists*/
   if(f1 ==NULL || f2 == NULL)
   {
      /* check whether both files have existed or typed in correctly*/
      if(f1 == NULL && f2 == NULL)
      {
      
         printf("Both files do not exist %s %s\n",menuFile,submenuFile);
      }
      /* check for each file existance*/
      else if (f1 == NULL)
      {
         printf("%s does not exist\n\n",menuFile);
      }
      /* check for each file existance*/
      else if(f2 == NULL)
      {
         printf("%s does not exist\n\n", submenuFile);
	 
      } 
      printf("EXITING PROGRAM ERROR!\n\n");
      return ERRORCODE; /* cannot proceed*/
   }
   
   /* counts how many fields there are in the file*/
   
   while(fgets(temp, LINE_LENGTH +2, f1)!=NULL)
   {
           
	   
           currentCat = menu->headCategory;
   
	   newCat = malloc(sizeof(CategoryType));
	   
	   
           if(prevCat == NULL)
	   {
	       menu->headCategory = newCat;
	       
	   
	   }
	  /* else
	   {
	       prevCat->nextCategory = newCat;
	      
	  */
   
           /* stores the catID but also checks if there
	   is a duplicate*/
	    
           catID = strtok(temp, "|");
	   
	   /* checking whether it tokenizez*/
	/*   if(catID == NULL)
	   {
	      printf("CatID missing\n");
	   }*/
	   strcpy(newCat->categoryID, catID);
	   
	   
	   /*checks for a duplication of the id field*/
	   if(!checkDuplicationID(menu, catID))
	   {
	      return ERRORCODE;
	   }
           /* gets the second field and tokenizez it*/
	   catType = strtok(NULL, "|");
	   newCat->drinkType = catType[0];
	   
	    /* checking whether it tokenizez*/
	   if(catType == NULL)
	   {
	      printf("CatType missing\n");
	   }
	   
	   
	   catName = strtok(NULL, "|");
	   strcpy(newCat->categoryName, catName);
	    /* checking whether it tokenizez*/
	    
	   if(catName == NULL)
	   {
	      printf("CatName missing\n");
	   }
	   
	   
	   catDescription = strtok(NULL, "\n");
	   strcpy(newCat->categoryDescription, catDescription);
	    /* checking whether it tokenizez*/
	   if(catDescription == NULL)
	   {
	      printf("CatDescription missing\n");
	   }
	   
	   /* checks the string length of the field*/
	   if((strlen(catID) >ID_LEN) ||
	      (strlen(catType) >MAX_NAME_LEN)  ||
	      (strlen(catDescription) >MAX_DESC_LEN))
	      
	   {	   
	   
	      printf("Wrong data format\n\n");
	      return ERRORCODE;
	      
	   }
	   
	   
	   
	   
	   /* put the pointer to the start of the list*/
	   
	   /*newCat->nextCategory = NULL;
	    newCat->headItem = NULL;
	    newCat->numItems = 0;
	    prevCat = newCat;*/
	    /*
	    currentCat = menu->headCategory;
	    prevCat = NULL;
	    
	   
	    
	    if(prevCat == NULL)
	    {
	       menu->headCategory = newCat;
	       newCat->nextCategory = currentCat;
	    
	    }
	    else
	    {
	       prevCat->nextCategory=newCat;
	       newCat->nextCategory = currentCat;
	    }*/
	    
	  
	    
	   
	      while(currentCat !=NULL)
	   {
	      printf("%s %c %s %s\n", currentCat->categoryID,
	      currentCat->drinkType,currentCat->categoryName,
	      currentCat->categoryDescription);
	      
	      currentCat = currentCat->nextCategory;
	   
	   }
	  
	 
	  
   }  /*end of while loop*/   
      
   while(fgets(tempf2, LINE_LENGTH +2, f1)!=NULL)
   {
           
	   
           currentItem = CategoryType->headItem;
   
	   newItem = malloc(sizeof(ItemType));
	   
	   
           if(prevItem == NULL)
	   {
	     /*  menu->headItem = newItem;*/
	       
	   
	   }
	 
	  
	    
	  
	  
	 
	  
   }  /*end of while loop*/   
   
   /* close both files after reading*/
   if(fclose(f1)!=0 || fclose(f2)!=0)
   {
      fprintf(stderr, "Error in closing files\n");
   }   
  

   return EXIT_SUCCESS;
}


/****************************************************************************
* Deallocates memory used in the program.
****************************************************************************/
void systemFree(GJCType* menu)
{

}

/*this function counts the number of tokens each line has*/
int countToken(FILE *fp, char* temp, int tokenPerLine)
{
   int countToken = 0;
   
   strtok(temp, "|");
   countToken++;
   
   
   /* while there are | delimeters count how many
   there are*/
   
   while(strtok(NULL, "|")!=NULL)
   {
      countToken++;
     
   }
  
   /* if its not a | delimeter then its the wrong data
   format*/
   
   if(countToken != tokenPerLine )
   {
      printf("\nWrong data format \n\n");
      
      return ERRORCODE;
   
   }
   return 1 ;/*countToken;*/

}

Code:
#ifndef GJC_OPTIONS_H
#define GJC_OPTIONS_H

/* Function prototypes. */
void displaySummary(GJCType* menu, char categoryType);
void categoryReport(GJCType* menu);
void addCategory(GJCType* menu);
void deleteCategory(GJCType* menu);
void addItem(GJCType* menu);
void deleteItem(GJCType* menu);
void saveData(GJCType* menu, char* menuFile, char* submenuFile);
int checkDuplicationID(GJCType *menu, char* catID);
int valid(char *p);
int checkNumInput(char input[]);
#endif

Code:
#include "gjc.h"
#include "gjc_options.h"
#include "gjc_utility.h"

/****************************************************************************
* Menu option #1: Display Summary
* Allows the user to display a summary of all hot or cold drink categories
* and items.
****************************************************************************/
void displaySummary(GJCType* menu, char categoryType)
{
}


/****************************************************************************
* Menu option #2: Category Report
* Allows the user to make a new report file for a chosen category.
****************************************************************************/
void categoryReport(GJCType* menu)
{
}


/****************************************************************************
* Menu option #3: Add Category
* Allows the user to add a new category record to the linked list.
****************************************************************************/
void addCategory(GJCType* menu)
{
}


/****************************************************************************
* Menu option #4: Delete Category
* Deletes a category and all corresponding items.
****************************************************************************/
void deleteCategory(GJCType* menu)
{
}


/****************************************************************************
* Menu option #5: Add Item
* Allows the user to add a new item to an existing category. An error 
* message is given if the category doesn't exist.
****************************************************************************/
void addItem(GJCType* menu)
{
}


/****************************************************************************
* Menu option #6: Delete Item
* Deletes a single item from a particular category.
****************************************************************************/
void deleteItem(GJCType* menu)
{
}


/****************************************************************************
* Menu option #7: Save and Exit
* Saves all system data back to the original files. This function does not
* terminate the program - this is left to the main() function instead.
****************************************************************************/
void saveData(GJCType* menu, char* menuFile, char* submenuFile)
{
}

/* checks for duplication of fields the catID field*/
int checkDuplicationID(GJCType *menu, char* catID)
{
    CategoryTypePtr current;
    current = NULL;
    
    current = menu->headCategory;
    
    
    while(current !=NULL)
    {
        if(strcmp(current->categoryID, catID) == ERRORCODE)
	{
	  printf("A duplicate record was found error:\n\n");
	  return ERRORCODE;
	}
        
        current = current->nextCategory;
    }
    
    return 1;
}

Code:
#include "gjc.h"
#include "gjc_options.h"
#include "gjc_utility.h"

int main(int argc, char* argv[])
{
   /* declaration of variables*/
   GJCType menu;
   
   
   int cmd;
   char *menuFile;
   char *submenuFile;
   int openData;
   
   /* to check how many command line aguments entered*/
   commandLineArguments(argc,argv);
   
   
   /* populating arguments with pointers to files*/
   menuFile = argv[1];
   submenuFile = argv[2];
   
   /*initialize variables and pointers*/
   systemInit(&menu);
   
   /* populate the data in the files into memory*/
   
   openData = loadData(&menu, menuFile, submenuFile);
   
   /* if it does not open release the memory*/
   if(!openData)
   {
       /*systemFree(&menu);*/
       return EXIT_SUCCESS;
   }

   return EXIT_SUCCESS;
}

int commandLineArguments(int argc, char *argv[])
{
  
    
   /* command line argument*/
   
   /* checks to see if 3 command line arguments have been entered*/
   if(argc<3)
   {
     
     printf("Invalid: Enter 3 command line arguments (Error:)\n");
     exit(ERRORCODE);
   }
   else if(argc >3)
   {
     printf("Too many arguments where supplied\n");
     return ERRORCODE;
   }
   
   
  
   return EXIT_SUCCESS;

}

Code:
#ifndef GJC_H
#define GJC_H

/* System-wide header files. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* System-wide constants. */
#define ID_LEN 5
#define MIN_NAME_LEN 1
#define MAX_NAME_LEN 25
#define MIN_DESC_LEN 1
#define MAX_DESC_LEN 250
#define NUM_PRICES 3
#define HOT 'H'
#define COLD 'C'
#define ERRORCODE 1
#define VALID 0
#define LINE_LENGTH 500
#define TOKEN_PRODUCT 4

typedef struct category* CategoryTypePtr;
typedef struct item* ItemTypePtr;

/* Structure definitions. */
typedef struct price
{
   unsigned dollars;
   unsigned cents;
} PriceType;

typedef struct item
{
   char itemID[ID_LEN + 1];
   char itemName[MAX_NAME_LEN + 1];
   PriceType prices[NUM_PRICES];
   char itemDescription[MAX_DESC_LEN];
   ItemTypePtr nextItem;
} ItemType;

typedef struct category
{
   char categoryID[ID_LEN + 1];
   char categoryName[MAX_NAME_LEN + 1];
   char drinkType;      /* (H)ot or (C)old. */
   char categoryDescription[MAX_DESC_LEN];
   CategoryTypePtr nextCategory;
   ItemTypePtr headItem;
   unsigned numItems;
} CategoryType;

typedef struct gjc
{
   CategoryTypePtr headCategory;
   unsigned numCategories;
} GJCType;

int commandLineArguments(int argc, char* argv[]);
int countToken(FILE *fp, char* temp, int tokenPerLine);
#endif