Program stops in the middle of for loop?

[nono]

I set a variable to NULL to get out of a for loop quicker. After tracing it through the debugger, I realized it makes the program halt at the for loop.


The program runs through the first part of case -1 and then I set p=null. It loops to the begining, reads the first line and stops.

for(p=first;p!=NULL;p=p->next){
	switch(strcmp(list->current->word,p->word)){
	case 0:
		list->current->count++;
		break;
	case -1:
		list->current->count=1;
		if(p==first){
			list->current->next=first;
			first=list->current;
		}else{
			list->current->next=p;
			Node * temp=p;
			p=list->current;
			list->current=temp;
		}
		p=NULL;
		break;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "WordStat.h"

#define HASHMAX 190271		/* prime number for size of hash table*/
#define MULT 31				/* hash multiplier */
FILE *fp;					/* file pointer */
Node *bin[HASHMAX];			/* creates link-list locations for hash table*/


int main(int argc, char **argv){
	//makeDict();
	//fp=fopen(*argv, "r");
	Stack();
	//fclose(fp);
	//printf("%d",argc);
	return 0;
}

void makeDict(){			/* creates a hash table of files from dict.txt */
	int i;
	char newWord[23];		/* longest word in dict is 23 chars*/
	for (i=0; i<HASHMAX; i++)
		bin[i]=NULL;
	fp=fopen ("dict.txt", "r");
	if(fp == NULL){
		puts("Error : Cannot Find Dictionary File");
		exit(1);
	}
	while(fgets(newWord, 23, fp)!=NULL){
		addWord(newWord);
	}
	fclose(fp);
}

void addWord(char *s){			/* adds word to hash table */
	Node * p;
	int h=hash(s);
	for(p=bin[h]; p!=NULL; p=p->next){
	}
	p=(Node *)malloc(sizeof(node));
	if(p == NULL){
			puts("Error : Cannot Allocate Memory");
			exit(1);
	}
	p->word=(char *)malloc(strlen(s)+1);
	strcpy(p->word, s);
	p->next=bin[h];
	bin[h]=p;
}

unsigned int hash(char *p){ 	/* creates hash value for word */
	unsigned int h=0;
	for(; *p; p++)
		h=MULT * h + *p;
	return h % HASHMAX;
}

//void del(struct wordList *s){
//	s->current->word=NULL;
//}

void Stack(){		/* creates a stack that holds one word at a time*/
	struct stacking let;
	struct wordList list;
//	del(&list);
	char c;
	fp=fopen ("test.txt", "r");
	while (c!=EOF){
		unsigned int stackCount=0;		/* counts length of current stack */
		clearStack(&let);
		c=toupper(getc(fp));
		while (isalpha(c)){
			push(&let,c);
			stackCount++;
			c=toupper(getc(fp));
		}
		char newWord[50];
		if (stackCount!=0)
			newWord[stackCount]='\0';
		if(stackCount>50){
			puts("Error : All Words Must Be Under 51 Characters");
			exit(1);
		}
		while (stackCount!=0){
			c=pop(&let);
			stackCount--;
			newWord[stackCount]=c;
		}
		list=alphab(newWord,&list);
	}
	fclose(fp);
//	while(list->current!=NULL){
//		printf("%s %d\t",list->current->word, list->current->count);
//		list->current=list->current->next;
//	}
	prant(&list);
}

void prant(struct wordList *gogogo){
	while(gogogo->current!=NULL){
		printf("%s %d\t",gogogo->current->word, gogogo->current->count);
		gogogo->current=gogogo->current->next;
	}
}

//int countLets(FILE *f){		/* returns length of the longest word */
//	char c;
//	int i,maxLen=0;
//	while (c!=EOF){
//		i=0;
//		c=getc(f);
//		while (isalpha(c)){
//			i++;
//			c=getc(f);
//		}
//		if (i>maxLen)
//			maxLen=i;
//	}
//	printf("\n%d",maxLen);
//	return maxLen;
//}

void clearStack(struct stacking *clear){		/* erases stack */
	clear->top=NULL;
	clear->current=NULL;
}

struct stacking push(struct stacking *stack,char c){/* adds element to stack*/
	stack->current=malloc(sizeof(struct node));
	if(stack->current == NULL){
			puts("Error : Cannot Allocate Memory");
			exit(1);
	}
	stack->current->let=c;
	stack->current->next=stack->top;
	stack->top=stack->current;
	return *stack;
}

char pop(struct stacking *stack){			/* removes element from stack */
	if (stack->top==NULL){
		puts("Error : Stack Is Empty");
		exit(0);
	}
	char popped=stack->top->let;
	stack->current=stack->top;
	stack->top=stack->top->next;
	free(stack->current);
	return popped;
}

struct wordList alphab(char *s,struct wordList *list){	/* adds word to linked-list alphabetically */
	Node * p,* first;
	first=list->current;
	p=(Node *)malloc(sizeof(node));
	if(p == NULL){
			puts("Error : Cannot Allocate Memory");
			exit(1);
	}
	p->word=(char *)malloc(strlen(s)+1);
	strcpy(p->word, s);
	list->current=p;
	if (first->count==3133){
		first=list->current;
		list->current->count=1;
	}else{
		for(p=first;p!=NULL;p=p->next){
			switch(strcmp(list->current->word,p->word)){
			case 0:
				list->current->count++;
				break;
			case -1:
				list->current->count=1;
				if(p==first){
					list->current->next=first;
					first=list->current;
				}else{
					list->current->next=p;
					Node * temp=p;
					p=list->current;
					list->current=temp;
				}
				p=NULL;
				break;
			case 1:
				if(p->next==NULL){
					p->next=list->current;
					list->current->count=1;
				}
				break;
			default:
				puts("Error : Incorrect Input");
				exit(1);
			}
		}
	}
//	while(list!=NULL){
//		printf("%s %d\t",list->current->word, list->current->count);
//		list->current=list->current->next;
//	}
	return *list;
}

Id really appreciate it if anybody could help me out here

[jsmith]

These two are equivalent in functionality:

for( p = first; p != NULL; p = p->next )
{
     /* stuff omitted here */
     p = NULL;
}

and

p = first;
while( p != NULL )
{
    /* stuff omitted here */
    p = NULL;
    p = p->next;   /* uh oh */
}