Salve , ho un problema di compilazione per una tabella dei simboli di un esercizio per un esame.
Quando compilo mi da questo errore e non riesco a capire il perché, qualcuno può aiutarmi??
Questo è l'errore che mi da il compilatore
Questo è il codice (spero si capisca)
#include <stdlib.h>
#include <stdio.h>
/*************************************************/
/* Definisco la dimensione della simbol table */
/* con un numero primo che servirà poi */
/* per la funzione di hashing. */
/*************************************************/
#define HASHSIZE 101
/****************************/
/* STRUTTURA PER I PRELIEVI */
/****************************/
typedef struct p{
int cifra;
struct p *next;
}prelievo;
typedef prelievo *PRELIEVO;
/******************************/
/* STRUTTURA PER I VERSAMENTI */
/******************************/
typedef struct v{
int cifra;
struct v *next;
}versamento;
typedef versamento *VERSAMENTO;
/*****************/
/* SYMBOL TABLE */
/*****************/
typedef struct s{
char *nome;
char *cf;
int sommePrelevate;
int sommeVersate;
VERSAMENTO sv;
PRELIEVO sp;
struct s *next;
}symbol;
typedef symbol *SYMBOL;
SYMBOL hashtable[HASHSIZE];
PRELIEVO sommaPrelevata=NULL;
VERSAMENTO sommaVersata=NULL;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Funzione hash. Usata per generare un hash che server come *
* accesso diretto alla locazione di memoria dell'elemento. *
* La funzione prende come parametro una stringa e genera un *
* intero senza segno attraverso dei calcoli effettuati su tutte *
* le lettere della stringa in modulo della dimensione della *
* symbol table (che è un numero primo), così facendo si ha la certezza *
* che possono essere utilizzate tutte le celle *
* di memoria messe a disposizione per la symbol table. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
unsigned int hash(char *nome) {
unsigned int h = 0;
for (; *nome != '\0'; nome++) {
h = (127 * h + *nome) % HASHSIZE;
}
return h;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* La funzione di lookup prende in ingresso una stringa e ne ricerca l'elemento *
* corrispondente all'interno della symbol table. Viene generato l'hash *
* corrispondente alla stringa, si recupera l'elemento memorizzato a quell'indirizzo *
* e con il ciclo for si scorre la lista degli elementi in quella posizione. Il ciclo *
* termina quando l'elemento è NULL o il paramentro "nome" corrisponde con l'elemento *
* ricercato. Nel caso in cui la lista in questa posizione non è ancora assegnata si *
* esce istantaneamente dal ciclo e viene ritornato l'elemento che in questo caso è NULL. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
SYMBOL lookupElement(char *nome) {
unsigned int h = hash(nome);
SYMBOL ans = hashtable[h];
for (; ans != NULL && ans->nome == nome; ans = ans->next);
return ans;
}
/***********************************/
/* LISTA SOMME PRELEVATE */
/***********************************/
PRELIEVO cifraPrelevata(int somma){
PRELIEVO p;
p = (PRELIEVO )malloc(sizeof(prelievo));
if(p==NULL)
return NULL;
else
{
p->cifra = somma;
p->next = sommaPrelevata;
sommaPrelevata = p;
}
return p;
}
/***********************************/
/* LISTA SOMME VERSATE */
/***********************************/
VERSAMENTO cifraVersata(int somma){
VERSAMENTO v;
v = (VERSAMENTO)malloc(sizeof(versamento));
if(v==NULL)
return NULL;
else
{
v->cifra = somma;
v->next = sommaVersata;
sommaVersata = v;
}
return v;
}
/*******************************************/
/* INSERIMENTO NELLA HASH TABLE */
/*******************************************/
SYMBOL insertElement(char *nome , char *cf){
SYMBOL ans = lookupElement(nome);
if(ans==NULL){
unsigned int h = hash(nome);
ans = (SYMBOL)malloc(sizeof(symbol));
int somma=0;
if(ans==NULL)
return NULL;
else
{
ans->nome = nome;
ans->cf = cf;
ans->sp = sommaPrelevata;
ans->sv = sommaVersata;
sommaPrelevata=NULL;
sommaVersata=NULL;
ans->sommePrelevate = sommaCifra(ans->sp);
ans->sommeVersate = sommaCifra(ans->sv);
ans->next = hashtable[h];
hashtable[h] = ans;
}
}
return ans;
}
/*************************************/
/* FUNZIONE PER SOMMARE */
/* I PRELIEVI */
/*************************************/
int sommaCifra(PRELIEVO p)
{
int somma=0;
if(p==NULL)
return -1;
else
{
while(p!= NULL)
{
somma = somma + p->cifra;
}
}
return somma;
}
/*************************************/
/* FUNZIONE PER SOMMARE */
/* I VERSAMENTI */
/*************************************/
int sommaCifra(VERSAMENTO v)
{
int somma=0;
if(v==NULL)
return -1;
else
{
while(v!= NULL)
{
somma = somma + v->cifra;
}
}
return somma;
}
/*******************************************/
/* FUNZIONE PER LIBERARE */
/* LA MEMORIA OCCUPATA */
/* DALLA TABELLA */
/*******************************************/
void freeTable() {
int i;
SYMBOL s, ans;
for (i = 0; i < HASHSIZE; i++) {
if (hashtable[i] != NULL) {
s = hashtable[i];
for (; s != NULL; s = s->next) {
ans = s;
free(ans);
}
}
}
}