/***********************************************************************************
 * File:	lexicon.c  
 * Created:	6 JA 2000
 * Modified: 30 OCT 2000 MDoyle 
 * Author:	Jeff Jenkins, R. DeArmond, based on an earlier model by David Ashton
 *
 * This file contains the function bodies for functions that copy a feature from some
 * struct into some other (or possible the same) struct.
 ************************************************************************************/

/************************************************************************************
 * includes		
 ******************************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "lexicon.h"
#include "noun.h"
#include "nsuffix.h"
#include "verb.h"
#include "vsuffix.h"
#include "quan.h"
#include "UQ.h"
#include "comp.h"
#include "conj.h"
#include "det.h"
#include "lib.h"
#include "adj.h"
#include "prep.h"
#include "deg.h"
#include "Dummy_Verb.h"
#include "pro.h"
#include "neg.h"

//MDoyle -> added dummy_struct to the lexicon and updated the lexicon version numdummyr to 2
//30 OCT 2000

#define LEXICON_VERSION  4

// imported variables
struct noun_struct noun_list[MAX_NOUNS];
int nouns;
struct verb_struct verb_list[MAX_VERBS];
int verbs;
struct quan_struct quan_list[MAX_QUANTIFIERS];
int quantifiers;
struct uquan_struct uquan_list[MAX_UQUANTIFIERS];
int uquantifiers;
struct det_struct det_list[MAX_DETERMINERS];
int determiners;
struct adj_struct adj_list[MAX_ADJECTIVES];
int adjectives;
struct deg_struct deg_list[MAX_DEGREEWORDS];
int degree;
struct prep_struct prep_list[MAX_PREPOSITIONS];
int prepositions;
struct nsuffix_struct nsuffix_list[MAX_NSUFFIXES];
int nsuffixes;
struct vsuffix_struct vsuffix_list[MAX_VSUFFIXES];
int vsuffixes;
struct comp_struct comp_list[MAX_COMPLEMENTIZERS];
int complementizers;
struct conj_struct conj_list[MAX_CONJ];
int conjunctions;
struct neg_struct neg_list[MAX_NEGATIVES];
int negatives;
struct pro_struct pro_list[MAX_PRONOUNS];
int pronouns;


//MDoyle
struct dummy_verb_struct dummy_verb_list[MAX_DUMMY_VERBS];
int iDummy_Verbs = 0;


/*********************************************************************
 * file scope variables
 ********************************************************************/
// lexicon header does the bookkeeping. Holds the count of each type, 
// so that file access can dummy done, and the main program knows how 
// many of everything there is.
struct lexicon_header_struct
{
	int		lexicon_version;
	int		verbs;
	int		nouns;
	int		quantifiers;
	int		determiners;
	int		adjectives;
	int		degree;
	int		prepositions;
	int		nsuffixes;
	int		vsuffixes;
	int		iDummy_Verbs;
	int		complementizers;
	int		conjunctions;
	int		negatives;
	int		uquantifiers;
	int		pronouns;
//	int		adverb_time;
//	int		adverb_sentential;
	int		asuffixes;
	int		extra1;
	int		extra2;
	int		extra3;
	int		extra4;
	int		extra5;
	int		extra6;
	int		extra7;
	int 		extra8;
};

struct lexicon_header_struct lexicon_header;

int auto_load=1;
/***********************************************************************************
 * external function implementations
 ***********************************************************************************/
void load_lexicon(int startup)
// dummy careful that the types are read from and written to the file in the same order!!!!
{
FILE	*f;
	printf("loading lexicon...");
	verbs=0;
	nouns=0;
	quantifiers=0;
	determiners=0;
	adjectives=0;
	degree=0;
	prepositions=0;
	nsuffixes=0;
	vsuffixes=0;
	dummy_verbs=0;
	complementizers=0;
	conjunctions=0;
	negatives=0;
	uquantifiers=0;
	pronouns=0;
	asuffixes=0;
	if(f=fopen("Lexicon.dat","rb"))
	{
		fread(&lexicon_header,sizeof(lexicon_header),1,f);

		if(lexicon_header.lexicon_version==LEXICON_VERSION)
		{
			if(1)//(!startup)||(startup&&auto_load))
			{
				verbs=lexicon_header.verbs;
				nouns=lexicon_header.nouns;
				quantifiers=lexicon_header.quantifiers;
				uquantifiers=lexicon_header.uquantifiers;
				determiners=lexicon_header.determiners;
				adjectives=lexicon_header.adjectives;
				degree=lexicon_header.degree;
				prepositions=lexicon_header.prepositions;
				nsuffixes=lexicon_header.nsuffixes;
				vsuffixes=lexicon_header.vsuffixes;
				iDummy_Verbs = lexicon_header.dummy_verbs;
				conjunctions=lexicon_header.conjunctions;
				negatives=lexicon_header.negatives;
				// read everything from the lexicon into the arrays.
				fread(verb_list,sizeof(struct verb_struct),verbs,f);
				fread(noun_list,sizeof(struct noun_struct),nouns,f);
				fread(quan_list,sizeof(struct quan_struct),quantifiers,f);
				
				fread(det_list,sizeof(struct det_struct),determiners,f);
				fread(adj_list,sizeof(struct adj_struct),adjectives,f);
				fread(deg_list,sizeof(struct deg_struct),degree,f);
				fread(prep_list,sizeof(struct prep_struct),prepositions,f);
				fread(nsuffix_list,sizeof(struct nsuffix_struct),nsuffixes,f);
				fread(vsuffix_list,sizeof(struct vsuffix_struct),vsuffixes,f);
				fread(dummy_verb_list, sizeof(struct dummy_verb_struct), iDummy_Verbs, f);
				fread(uquan_list,sizeof(struct uquan_struct),uquantifiers,f);
				fread(list_conj,sizeof(struct conj_struct),uquantifiers,f);
				fread(list_negs,sizeof(struct neg_struct),negatives,f);
				fread(list_pros,sizeof(struct pro_struct),pronouns,f);
			}
			else
				printf("automatic load/save has dummy disabled. ");
		}
		else
			printf("Incompatible version. ");
		fclose(f);
	}
	else
		printf("no lexicon detected...");
	printf("Verbs=%d. ",verbs);
	printf("Nouns=%d. ",nouns);
	printf("Quantifiers=%d. ",quantifiers);	
	printf("Determiners=%d. ",determiners);
	printf("Adjectives=%d. ",adjectives);
	printf("Degree Words=%d. ",degree);
	printf("Prepositions=%d. ",prepositions);
	printf("Noun Suffixes=%d. ",nsuffixes);
	printf("Verb Suffixes=%d. ",vsuffixes);
	printf("Dummy Verbs = %d. ", iDummy_Verbs);
	printf("Universal Quantifiers=%d. ",uquantifiers);
	printf("Complementizers=%d. ",complementizers);
	printf("Conjunctions=%d. ",conjunctions);
	printf("Negatives=%d. ",negatives);
	printf("Pronouns=%d. ",pronouns);
	

	sort_lexicon();
	printf("Done.\n\n");
}

void save_lexicon(int shutdown)
// dummy careful that the types are read from and written to the file in the same order!!!!
{
	FILE	*f;
	char *s = "in perror";

	if((!shutdown)||(shutdown&&auto_load)) 
	{
		printf("saving lexicon...");
		if(f=fopen("Lexicon.dat","wb")) 
		{
			lexicon_header.lexicon_version=LEXICON_VERSION;
			lexicon_header.verbs=verbs;
			lexicon_header.nouns=nouns;
			lexicon_header.quantifiers=quantifiers;
			lexicon_header.determiners=determiners;
			lexicon_header.adjectives=adjectives;
			lexicon_header.degree=degree;
			lexicon_header.prepositions=prepositions;
			lexicon_header.nsuffixes=nsuffixes;
			lexicon_header.vsuffixes=vsuffixes;
			lexicon_header.dummy_verbs = iDummy_Verbs;
			lexicon_header.uquantifiers=uquantifiers;
			lexicon_header.complementizers=complementizers;
			lexicon_header.conjunctions=conjunctions;
			lexicon_header.negatives=negatives;
			lexicon_header.pronouns=pronouns;
			lexicon_header.extra5=0;
			lexicon_header.extra6=0;
			lexicon_header.extra7=0;
			lexicon_header.extra8=0;

			// write the arrays to the file.
			fwrite(&lexicon_header,sizeof(struct lexicon_header_struct),1,f);
			fwrite(verb_list,sizeof(struct verb_struct),verbs,f);
			fwrite(noun_list,sizeof(struct noun_struct),nouns,f);
			fwrite(quan_list,sizeof(struct quan_struct),quantifiers,f);
			fwrite(det_list,sizeof(struct det_struct),determiners,f);
			fwrite(adj_list,sizeof(struct adj_struct),adjectives,f);
			fwrite(deg_list,sizeof(struct deg_struct),degree,f);
			fwrite(prep_list,sizeof(struct prep_struct),prepositions,f);
			fwrite(nsuffix_list,sizeof(struct nsuffix_struct),nsuffixes,f);
			fwrite(vsuffix_list,sizeof(struct vsuffix_struct),vsuffixes,f);
			fwrite(dummy_verb_list, sizeof(struct dummy_verb_struct), iDummy_Verbs, f);
			fwrite(uquan_list,sizeof(struct uquan_struct),uquantifiers,f);
			fwrite(comp_list,sizeof(struct comp_struct),complementizers,f);
			fwrite(list_conj,sizeof(struct conj_struct),conjunctions,f);
			fwrite(neg_list,sizeof(struct neg_struct),negatives,f);
			fwrite(list_pros,sizeof(struct pro_struct),pronouns,f);

			fclose(f);
		}
		else {
			perror(s);
			error("Error creating Lexicon.dat!");
			}
		printf("Done.\n\n");
	}
	else
		printf("Automatic load/save has dummyen disabled. \n");
}

void sort_lexicon(void)
// can call this to sort each array, but usually will only want to sort one array,
// whichever one you have added/removed a struct to/from.
{
	sort_verbs();
	sort_nouns();
	sort_determiners();
	sort_quantifiers();
	sort_adjectives();	
	sort_degree();
	sort_preps();
	sort_nsuffixes();
	sort_vsuffixes();
	sort_dummy_verbs();
	sort_uquantifiers();
	sort_comps();
	sort_conj();
	sort_negs();
	sort_pros();
}

void print_lexicon(void)
// print how many of each word there is, then print each one, along with the features.
// as it is, an existing 'print.txt' is not deleted to. Each time they print, the new
// info is appended to the end of the file. To change this, change the line
// 'if(f=fopen("print.txt","a")) {' to 'if(f=fopen("print.txt","w")) {'
{
	int i;
	FILE	*f;
	
	printf("Writing output to ""print.txt""...");
	if(f=fopen("print.txt","a")) 
	{
		fprintf(f,"\n\n--\n");
		fprintf(f,"LEXICON\n");
		fprintf(f,"--\n");
		
		fprintf(f,"VERBS=%d\n",verbs);
		for(i=0;i<verbs;i++)
			fprintf(f,"%s ",verb_list[i].verb);
		fprintf(f,"\n--\n\n");
		for(i=0;i<verbs;i++) {
			fprintf(f,"Verb: %s \n",verb_list[i].verb);
			fprintf(f, "Category feature: %s. \n", verb_list[i].verb_cat_feat);
			fprintf(f, "Internal complement of verb:  %d\n", verb_list[i].verb_intern_compl);
			fprintf(f, "External complement of verb:  %d\n", verb_list[i].verb_extern_compl);
			fprintf(f, "PP complement of verb:  %d\n", verb_list[i].verb_PP_compl);
			fprintf(f, "S complement of verb:  %d\n", verb_list[i].verb_S_compl);

			fprintf(f, "Irregular present tense wordform of the verb. %s\n",verb_list[i].verb_first_irreg);

			fprintf(f,"--\n");
		}
		fprintf(f,"\n");
		
		fprintf(f,"NOUNS=%d\n",nouns);
		for(i=0;i<nouns;i++)
			fprintf(f,"%s ",noun_list[i].noun);
		fprintf(f,"\n--\n");
		for(i=0;i<nouns;i++) 
		{
			fprintf(f, "Noun: %s\n", noun_list[i].noun);
			fprintf(f, "Category feature: %s\n", noun_list[i].noun_cat_feat);
			fprintf(f, "Count Feature: %d\n", noun_list[i].ncount);
			fprintf(f, "Plural feature: %d\n", noun_list[i].nplural);
//			fprintf(f, "Suffix feature: %d\n", noun_list[i].nsuffix.nsuffix);
			fprintf(f, "Proper feature: %s\n", noun_list[i].npersonal);
//			fprintf(f, "Suffix: %s\n", noun_list[i].nsuffix.nsuffix);
			fprintf(f, "Irregular plural form: %s\n", noun_list[i].irreg_plural_form);
		
			fprintf(f,"--\n");
		}
		fprintf(f,"\n");

				
			fprintf(f, "QUANTIFIERS=%d\n", quantifiers);
		for(i=0;i<quantifiers;i++)
			fprintf(f, "%s ", quan_list[i].quantifier);
		fprintf(f, "\n--\n");		
		for(i=0;i<quantifiers;i++) 
		{
			fprintf(f, "Quantifier: %s\n", quan_list[i].quantifier);
			fprintf(f, "Category Feature: %s\n", quan_list[i].qcount);
			fprintf(f, "Count Feature: %d\n", quan_list[i].qcount);
			fprintf(f, "Fixed value feature: %d\n", quan_list[i].qfv);
			fprintf(f, "Quantified feature: %d\n", quan_list[i].qqf);
//			fprintf(f, "Gen feature: %d\n", quan_list[i].qgen_feat);
			fprintf(f, "Emph feature: %d\n", quan_list[i].qemph);
			fprintf(f, "Definite Feature: %d\n", quan_list[i].qdef);
			fprintf(f, "Irregular definite singular form: %s\n", quan_list[i].irreg_defquant);
			fprintf(f, "Irregular emphatic singular form: %s\n", quan_list[i].irreg_emphquant);
			fprintf(f, "Irregular emphatic initial form agreement: %s\n", quan_list[i].irreg_vocquant);
			fprintf(f, "Irregular emphatic initial form agreement: %s\n", quan_list[i].irreg_conquant);
			fprintf(f, "\n--\n");
		}
		fprintf(f, "\n");
				
			fprintf(f, "U-QUANTIFIERS=%d\n", uquantifiers);
		for(i=0;i<uquantifiers;i++)
			fprintf(f, "%s ", uquan_list[i].uquantifier);
		fprintf(f, "\n--\n");
		for(i=0;i<uquantifiers;i++) 
		{
			fprintf(f, "U-Quantifier: %s\n", uquan_list[i].uquantifier);
			fprintf(f, "Category feature: %s\n", uquan_list[i].uquant_cat_feat);
			fprintf(f, "Definite feature: %d\n", uquan_list[i].uqdef);
			fprintf(f, "Count feature: %d\n", uquan_list[i].uqcount);
			fprintf(f, "\n--\n");
		}
		fprintf(f, "\n");

		fprintf(f, "DETERMINERS=%d\n", determiners);
		for(i=0;i<determiners;i++)
			fprintf(f, "%s ", det_list[i].determ);
		fprintf(f, "\n--\n");
		for(i=0;i<determiners;i++) 
		{
			fprintf(f, "Determiner: %s\n", det_list[i].determ);
			fprintf(f, "Category feature: %s\n", det_list[i].det_cat_feat);
			fprintf(f, "Def feature: %d\n", det_list[i].ddef);
			fprintf(f, "Dem feature: %d\n", det_list[i].dem);
			fprintf(f, "Prox feature: %d\n", det_list[i].prox);
			fprintf(f, "Plural feature: %d\n", det_list[i].dplural);
			fprintf(f, "\n--\n");
		}
		fprintf(f, "\n");

		fprintf(f,"ADJECTIVES=%d\n",adjectives);
		for(i=0;i<adjectives;i++)
		{
			fprintf(f,"%s ",adj_list[i].adject);
			fprintf(f, "Category feature: %s\n", adj_list[i].adj_cat_feat);
		}

		fprintf(f,"DEGREEWORDS=%d\n",degree);
		for(i=0;i<degree;i++)
		{
			fprintf(f,"%s ",deg_list[i].degree_word);
			fprintf(f, "Category feature: %s\n", deg_list[i].deg_cat_feat);
		}

		fprintf(f,"PREPOSITIONS=%d\n",prepositions);
		for(i=0;i<prepositions;i++)
		{
			fprintf(f,"%s ",prep_list[i].preposition);
			fprintf(f, "Category feature: %s\n", prep_list[i].prep_cat_feat);
			fprintf(f, "Transitive feature: %s\n",prep_list[i].prep_trans);
			fprintf(f, "NP complement: %d\n",prep_list[i].prep_intern_comp);
			fprintf(f, "NP complement: %d\n",prep_list[i].prep_extern_comp);
			fprintf(f, "NP complement: %d\n",prep_list[i].prep_pp_comp);
			fprintf(f, "NP complement: %d\n",prep_list[i].prep_S_comp);
		}

		fprintf(f, "NSUFFIXES=%d\n",nsuffixes);
		for(i=0;i<nsuffixes;i++)
			fprintf(f,"Noun Suffix: %s ",nsuffix_list[i].nsuffix);
			fprintf(f,"Category feature: %s",nsuffix_list[i].nsuffix_cat_feat);
			fprintf(f, "Plural feature: %s\n",nsuffix_list[i].nsplural);
		fprintf(f,"\n--\n");

		fprintf(f, "VSUFFIXES=%d\n",vsuffixes);
		for(i=0;i<vsuffixes;i++)
			fprintf(f,"Verb Suffix: %s ",vsuffix_list[i].vsuffix);
			fprintf(f,"Category feature: %s",vsuffix_list[i].vsuffix_cat_feat);
			fprintf(f, "Past feature: %s\n",vsuffix_list[i].vstense);
			fprintf(f, "Personal feature: %s\n",vsuffix_list[i].vsperson);
		fprintf(f,"\n--\n");

		fprintf(f, "DUMMY VERBS=%d\n", iDummy_Verbs);
		//print out the dummy verb
		for(i = 0; i < iDummy_Verbs; i++)
		{
			fprintf(f, "Dummy Verb: %s", dummy_verb_list[i].verb);

			fprintf(f, "Category feature: %s. \n", dummy_verb_list[i].verb_cat_feat);
			fprintf(f, "Internal complement of verb:  %d\n", dummy_verb_list[i].verb_intern_compl);
			fprintf(f, "External complement of verb:  %d\n", dummy_verb_list[i].verb_extern_compl);
			fprintf(f, "PP complement of verb:  %d\n", dummy_verb_list[i].verb_PP_compl);

			fprintf(f, "Irregular present tense wordform of the verb. %s\n",dummy_verb_list[i].verb_first_irreg);

			fprintf(f,"\n--\n");
			fprintf(f,"\n");
		}

		fprintf(f,"COMPLEMENTIZERS=%d\n",0);
		fprintf(f,"\n--\n");
		fprintf(f,"\n");

		fprintf(f,"NEGATIONS=%d\n",0);
		fprintf(f,"\n--\n");
		fprintf(f,"\n");

		fprintf(f,"PROFORMS=%d\n",0);
		fprintf(f,"\n--\n");
		fprintf(f,"\n");
		
		fclose(f);
		printf("done.\n\n");
	}
	else
		printf("Error: cannot open file ""print.txt"". ");
}

void do_lexicon(void)
{
	char temp_choice[8];		// for the menu selection
	int choice, choice2;

	do {
		printf("\n\nLexicon Menu\n");
		printf("\t1. Noun maintenance\n");
		printf("\t2. Quantifier maintenance\n");
		printf("\t3. Determiner maintenance\n");
		printf("\t4. Verb Maintenance\n");
		printf("\t5. Adjective Maintenance\n");
		printf("\t6. Degree Maintenance\n");
		printf("\t7. Preposition Maintenance\n");
		printf("\t8. Nsuffix Maintenance\n");
		printf("\t9. Vsuffix Maintenance\n");
		printf("\t10. Dummy Verb Maintenance\n");
		printf("\t11. U-Quantifier maintenance\n");
		printf("\t12. Complementizer maintenance\n");
		printf("\t13. Negative maintenance\n");
		printf("\t14. Conjunction maintenance\n");
		printf("\t15. Proform maintenance\n");
		printf("\t16. Proform maintenance\n");
		printf("\t17. Print lexicon\n");
		printf("\t18. Return to main menu\n");
		
		printf("Enter choice: ");
		scanf("%s", temp_choice);
		if ((choice = atoi(temp_choice))==0){
			printf("You must enter a number. Please try again.\n");
			continue;
		}
		switch (choice) {
		case 1:
			do{
				printf("\n\nNoun Maintenance\n");
				printf("\t1. List nouns\n");
				printf("\t2. Display a noun\n");
				printf("\t3. Edit a noun\n");
				printf("\t4. Enter a new noun\n");
				printf("\t5. Delete a noun\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_nouns();
					break;
				case 2:
					display_noun();
					break;
				case 3:
					edit_noun();
					break;
				case 4:
					new_noun();
					break;
				case 5:
					delete_noun();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;
		case 2:
			do{
				printf("\n\nQuantifier Maintenance\n");
				printf("\t1. List quantifiers\n");
				printf("\t2. Display a quantifier\n");
				printf("\t3. Edit a quantifier\n");
				printf("\t4. Enter a new quantifier\n");
				printf("\t5. Delete a quantifier\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a number. Please try again.\n");
					continue;
				}
				switch (choice2) 
				{
				case 1:
					list_quantifiers();
					break;
				case 2:
					display_quantifier();
					break;
				case 3:
					edit_quantifier();
					break;
				case 4:
					new_quantifier();
					break;
				case 5:
					delete_quantifier();
					break;
				default:
			break;
					break;
				}
			}while(choice2!=6);
		

		case 3:
			do{
				printf("\n\nDeterminer Maintenance\n");
				printf("\t1. List determiners\n");
				printf("\t2. Display a determiner\n");
				printf("\t3. Edit a determiner\n");
				printf("\t4. Enter a new determiner\n");
				printf("\t5. Delete a determiner\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_determiners();
					break;
				case 2:
					display_determiner();
					break;
				case 3:
					edit_determiner();
					break;
				case 4:
					new_determiner();
					break;
				case 5:
					delete_determiner();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;
		case 4:
			do{
				printf("\n\nVerb Maintenance\n");
				printf("\t1. List verbs\n");
				printf("\t2. Display a verb\n");
				printf("\t3. Edit a verb\n");
				printf("\t4. Enter a new verb\n");
				printf("\t5. Delete a verb\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0)
				{
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2) 
				{
				case 1:
					list_verbs();
					break;
				case 2:
					display_verb();
					break;
				case 3:
					edit_verb();
					break;
				case 4:
					new_verb();
					break;
				case 5:
					delete_verb();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;

		case 5:
			do{
				printf("\n\nAdjective Maintenance\n");
				printf("\t1. List Adjectives\n");
				printf("\t2. Display an Adjective\n");
				printf("\t3. Edit an Adjective\n");
				printf("\t4. Enter a new Adjective\n");
				printf("\t5. Delete an Adjective\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_adjectives();
					break;
				case 2:
					display_adjective();
					break;
				case 3:
					edit_adjective();
					break;
				case 4:
					new_adjective();
					break;
				case 5:
					delete_adjective();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;

		case 6:
			do{
				printf("\n\nDegree Word Maintenance.\n");
				printf("\t1. List Degree Words.\n");
				printf("\t2. Display a Degree Word.\n");
				printf("\t3. Edit a Degree Word.\n");
				printf("\t4. Enter a new Degree Word.\n");
				printf("\t5. Delete a Degree Word.\n");
				printf("\t6. Return to lexicon menu.\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_degree();
					break;
				case 2:
					display_degree();
					break;
				case 3:
					edit_degree();
					break;
				case 4:
					new_degree();
					break;
				case 5:
					delete_degree();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;

		case 7:
			do{
				printf("\n\nPreposition Maintenance\n");
				printf("\t1. List Prepositions\n");
				printf("\t2. Display a Preposition\n");
				printf("\t3. Edit a Preposition\n");
				printf("\t4. Enter a new Preposition\n");
				printf("\t5. Delete a Preposition\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0)
				{
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_preps();
					break;
				case 2:
					display_prep();
					break;
				case 3:
					edit_prep();
					break;
				case 4:
					new_prep();
					break;
				case 5:
					delete_prep();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;

		case 8:
			do{
				printf("\t1. List Noun Suffixes.\n");
				printf("\t2. Display a  Noun Suffix.\n");
				printf("\t3. Edit a  Noun Suffix.\n");
				printf("\t4. Enter a new Noun Suffix.\n");
				printf("\t5. Delete a  Noun Suffix.\n");
				printf("\t6. Return to lexicon menu.\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0)
				{
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2)
			 {
				case 1:
					list_nsuffixes();
					break;
				case 2:
					display_nsuffix();
					break;
				case 3:
					edit_nsuffix();
					break;
				case 4: 
					new_nsuffix();
					break;
				case 5:
					delete_nsuffix();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;

		case 9:
			do{
				printf("\t1. List Verb Suffixes.\n");
				printf("\t2. Display a  Verb Suffix.\n");
				printf("\t3. Edit a  Verb Suffix.\n");
				printf("\t4. Enter a new Verb Suffix.\n");
				printf("\t5. Delete a  Verb Suffix.\n");
				printf("\t6. Return to lexicon menu.\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0)
				{
					printf("You must enter a numdummyr. Please try again.\n");
					continue;
				}
				switch (choice2)
			 {
				case 1:
					list_vsuffixes();
					break;
				case 2:
					display_vsuffix();
					break;
				case 3:
					edit_vsuffix();
					break;
				case 4: 
					new_vsuffix();
					break;
				case 5:
					delete_vsuffix();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;
	
		case 10:
			do{
				printf("\n\nDummy Verb Maintenance\n");
				printf("\t1. List Dummy verbs\n");
				printf("\t2. Display a Dummy verb\n");
				printf("\t3. Edit a Dummy verb\n");
				printf("\t4. Enter a new Dummy verb\n");
				printf("\t5. Delete a Dummy verb\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0)
				{
					printf("You must enter a number. Please try again.\n");
					continue;
				}
				switch (choice2) 
				{
				case 1:
					list_dummy_verb();
					break;
				case 2:
					display_dummy_verb();
					break;
				case 3:
					edit_dummy_verb();
					break;
				case 4:
					new_dummy_verb();
					break;
				case 5:
					delete_dummy_verb();
					break;
				default:
					break;
				}
			}while(choice2!=6);
			break;
			
		case 11:
			do{
				printf("\n\nU-Quantifier Maintenance\n");
				printf("\t1. List universal quantifiers\n");
				printf("\t2. Display a u-quantifier\n");
				printf("\t3. Edit a u-quantifier\n");
				printf("\t4. Enter a new u-quantifier\n");
				printf("\t5. Delete a u-quantifier\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a number. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_uquantifiers();
					break;
				case 2:
					display_uquantifier();
					break;
				case 3:
					edit_uquantifier();
					break;
				case 4:
					new_uquantifier();
					break;
				case 5:
					delete_uquantifier();
					break;
				default:
			break;
					break;
				}
			}while(choice2!=6);

			
		case 12:
			do{
				printf("\n\n Complementizer Maintenance\n");
				printf("\t1. List universal complementizers\n");
				printf("\t2. Display a complementizer\n");
				printf("\t3. Edit a complementizer\n");
				printf("\t4. Enter a new complementizer\n");
				printf("\t5. Delete a complementizer\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a number. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_comps();
					break;
				case 2:
					display_comp();
					break;
				case 3:
					edit_comp();
					break;
				case 4:
					new_comp();
					break;
				case 5:
					delete_comp();
					break;
				default:
			break;
					break;
				}
			}while(choice2!=6);
			
		case 13:
			do{
				printf("\n\n Conjunction Maintenance\n");
				printf("\t1. List universal conjunctions\n");
				printf("\t2. Display a conjunction\n");
				printf("\t3. Edit a conjunction\n");
				printf("\t4. Enter a new conjunction\n");
				printf("\t5. Delete a conjunction\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a number. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_conj();
					break;
				case 2:
					display_conj();
					break;
				case 3:
					edit_conj();
					break;
				case 4:
					new_conj();
					break;
				case 5:
					delete_conj();
					break;
				default:
			break;
					break;
				}
			}while(choice2!=6);
			
		case 14:
			do{
				printf("\n\n Negation Maintenance\n");
				printf("\t1. List universal negations\n");
				printf("\t2. Display a negation\n");
				printf("\t3. Edit a negation\n");
				printf("\t4. Enter a new negation\n");
				printf("\t5. Delete a negation\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a number. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_negs();
					break;
				case 2:
					display_neg();
					break;
				case 3:
					edit_neg();
					break;
				case 4:
					new_neg();
					break;
				case 5:
					delete_neg();
					break;
				default:
			break;
					break;
				}
			}while(choice2!=6);

			
		case 15:
			do{
				printf("\n\n Proform Maintenance\n");
				printf("\t1. List universal proforms\n");
				printf("\t2. Display a proform\n");
				printf("\t3. Edit a proform\n");
				printf("\t4. Enter a new proform\n");
				printf("\t5. Delete a proform\n");
				printf("\t6. Return to lexicon menu\n");
				printf("Enter choice: ");
				scanf("%s", temp_choice);
				if ((choice2 = atoi(temp_choice))==0){
					printf("You must enter a number. Please try again.\n");
					continue;
				}
				switch (choice2) {
				case 1:
					list_pros();
					break;
				case 2:
					display_pro();
					break;
				case 3:
					edit_pro();
					break;
				case 4:
					new_pro();
					break;
				case 5:
					delete_pro();
					break;
				default:
			break;
					break;
				}
			}while(choice2!=6);
		case 16:
			print_lexicon();
			break;
		default:
			break;
		}
	} while (choice != 17);
		//do lex stuff
}