[C] Problemi di compilazione

[Manugal]

Ciao...

Allora ho un progetto da fare per l'università è mi hanno fornito tutta la gerarchia delle directory che si presenta in questo modo:


DBF/
doc/ contiene la documentazione relativa al progetto
include/ contiene un header da includere in tutti i moduli del progetto
Modulo1/ il modulo che devo compilare
Modulo2/
Modulo3/
Modulo4/
obj/ una volta compilato un modulo qui andrà il file .o della gest. errori
src/ c'è il sorgente della funzione che gestisce gli errori


Per compilare devo entrare nella cartella Modulo1 e digitare make test. La cartella Modulo1 si presenta così:


Modulo1/
doc/ documentazione inerente questo Modulo
include/ ci va un header che creo per contenere costanti, struct e prototipi di funzione
lib/ dopo la compilazione ci aggiunge il file Modulo1.a
obj/ dopo la compilazione ci aggiunge i file .o dei sorgenti da me creati
src/ sorgenti da me creati
test/ qui dentro ci sono le funzioni per testare la funzionalità dei miei sorgenti
makefile penso che sappiate tutti cosa sia :)



Praticamente entro dentro la cartella Modulo1, lancio make test e poi dovrei andare nella cartella test e lanciare ./TestM1 (creato durante la fase di compilazione), solamente che mi dice sempre "Permission Denied" (sia se sono root che user normale) e la cosa strana è che ha anche i permessi di esecuzione :confused:

Da cosa può dipendere questo comportamento?

Grazie.

[Manugal]

Se può esservi utile vi faccio vede come è fatto il makefile:



####################
# Comandi e flags
AR=ar
CC=gcc
DEBUG=-g
CCFLAGS= -c $(DEBUG)
ARFLAGS= rc

# Directories
SRCDIR=src
OBJDIR=obj
LIBDIR=lib
TESTDIR=test
ERROBJDIR=../obj
ERRSRCDIR=../src

# Include e altre libs
INCLUDE=-I include -I ../include
LIBS =

# Elementi da creare
LIBMODULE = Modulo1.a
TESTEXE = TestM1

# Elementi da utilizzare
OBJS = $(OBJDIR)/LPC_Common.o $(OBJDIR)/LPC_CreateDBF.o $(OBJDIR)/LPC_DeleteDBF.o
TESTOBJ = $(TESTDIR)/TestM1.o
ERROBJ=$(ERROBJDIR)/LPC_Err.o

TARGET=$(LIBDIR)/$(LIBMODULE)
TEST=$(TESTDIR)/$(TESTEXE)

# Dipendenze
$(OBJDIR)/%.o : $(SRCDIR)/%.c
$(CC) $(CCFLAGS) $(INCLUDE) $< -o $@

$(TESTDIR)/%.o : $(TESTDIR)/%.c
$(CC) $(CCFLAGS) $(INCLUDE) $< -o $@

$(ERROBJDIR)/%.o : $(ERRSRCDIR)/%.c
$(CC) $(CCFLAGS) $(INCLUDE) $< -o $@

# Target

$(TARGET): $(OBJS)
$(AR) $(ARFLAGS) $@ $?

$(TEST): $(TESTOBJ) $(ERROBJ) $(TARGET)
$(CC) $(TESTOBJ) $(ERROBJ) $(TARGET) -o $(TEST)


all: $(TARGET) $(TEST)

module: $(TARGET)

test: $(TEST)

clean:
rm -f $(OBJS)
rm -f $(TARGET)
rm -f $(TEST)
rm -f $(TESTOBJ)

[Manugal]

Ho risolto. Ho fatto partire il progetto dalla partizione dove ho installato Linux (mentre prima lo facevo partire su una partizione FAT32) ed ora va. Grazie lo stesso ;)

[Manugal]

Senza che apro un nuovo thread (perché tanto sempre di compilazione si tratta :) ) avevo bisogno di un aiuto riguardo la compilazione del mio progetto. Allora vi posto sia il codice della funzione che testa il mio codice sia il mio codice.

Test:

void TestCreate(void)
{
int ret= 0;
int NumFields = 0;
FILE *fp;
FIELD_DATA_t FieldData[MAX_NUM_FIELDS];
int len, len1;
char buf[500], buftest[500];

// Verifica correttezza
test[numtest].testid = 10113;
test[numtest].weight = 10;
strcpy(test[numtest].desc, "CREATE: Verifica correttezza");
printf("Test:[%d] Peso:[%d] - [%s]\n", test[numtest].testid, test[numtest].weight,test[numtest].desc);
for(;;)
{
ret = -1;

fp = fopen("ProvaTest.dbf", "r");
len = fread(buftest, sizeof(char), 500, fp);
fclose(fp);

fp = fopen("Prova.dbf", "r");
len1 = fread(buf, sizeof(char), 500, fp);
fclose(fp);
if (len1 != len)
break;

// Confronto la prima parte (prima del timestamp)
len = DBF_NAME_LENGTH+1+2+4+2+2;
if (memcmp(buf, buftest, len))
break;

// Confronto la seconda parte (dopo il timestamp)
if (memcmp(buf+len+4, buftest+len+4, len1-len-4))
break;

ret = LPC_OK;
break;
}
if (ret == LPC_OK)
test[numtest].passed = 1;
numtest++;

Result("CREATE");

}


Mio codice: (lo posto per intero cmq dovrebbe servire solo l'ultima parte dalla fwrite in poi)


#include "LPC_M1_Include.h"
#include "LPC_Include.h"
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>

int CreateDatabaseFile(char *Name, int NumFields, FIELD_DATA_t *FieldData){
int test;
int i;
char *finale;
header *h;
Name=(char *)malloc(sizeof(char)*DBF_NAME_LENGTH);
FieldData=(FIELD_DATA_t *)malloc(sizeof(FIELD_DATA_t));
if((Name==NULL) || (cercaErr(Name)==1)){
char Err1[256];
(void) sprintf(Err1, "Nome DB nullo o non valido o NumFields<=0");
LPC_GestioneErrore(LPC_BAD_ARG, "CreateDatabaseFile", Err1);
return LPC_BAD_ARG;
}
if((NumFields<=0) || (NumFields>MAX_NUM_FIELDS)){
char Err10[256];
(void) sprintf(Err10, "Nome DB nullo o non valido o NumFields<=0");
LPC_GestioneErrore(LPC_BAD_ARG, "CreateDatabaseFile", Err10);
return LPC_BAD_ARG;
}
h=(header *)malloc(sizeof(header)*(DBF_FIXED_HEADER_LEN+MAX_NUM_FIELDS*(DBF_FIELD_LEN+MAX_NUM_FIELDS)+2));
if(h==NULL){
char Err4[256];
(void) sprintf(Err4, "Errore allocazione memoria");
LPC_GestioneErrore(LPC_NO_MEMORY, "CreateDatabaseFile", Err4);
return LPC_NO_MEMORY;
}
if(strlen(Name)>DBF_NAME_LENGTH+1)
Name[DBF_NAME_LENGTH+1]='\0';
finale=strcat(Name,DBF_EXTENSION);
if((test=access(finale,F_OK))==0){
char Err2[256];
(void) sprintf(Err2, "File DBF già esistente");
LPC_GestioneErrore(LPC_FILE_EXISTS, "CreateDatabaseFile", Err2);
return LPC_FILE_EXISTS;
}
FILE *fp=fopen(strcat(Name,DBF_OPEN_EXT),"wb+");
if(fp==NULL){
char Err3[256];
(void) sprintf(Err3, "Errore allocazione memoria");
LPC_GestioneErrore(LPC_NO_MEMORY, "CreateDatabaseFile", Err3);
return LPC_NO_MEMORY;
}
h->NumCampi=(uint16_t) htons(h->NumCampi);
h->NumCampi=NumFields;
h->NumRecords=(uint32_t) htonl(h->NumRecords);
h->NumRecords=0;
h->dimHeader=(uint16_t) htons(h->dimHeader);
h->dimHeader=DBF_FIXED_HEADER_LEN+NumFields*(DBF_FIELD_LEN+NumFields)+2;
h->dimRecord=(uint16_t) htons(h->dimRecord);
h->dimRecord=0;
h->timestamp=(uint32_t) htonl(h->timestamp);
h->timestamp=time(NULL);
for(i=0; i<NumFields; ++i){
if(cercaErr(FieldData->Name)==1){
char Err5[256];
(void) sprintf(Err5, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err5);
return LPC_BAD_FIELD;
}
if(StringaUguale(FieldData->Name,h,i)==1){
char Err8[256];
(void) sprintf(Err8, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err8);
return LPC_BAD_FIELD;
}
strcpy(h->campo[i].name,FieldData->Name);
if ((FieldData->FieldType!=CHARACTER) || (FieldData->FieldType!=NUMERIC) || (FieldData->FieldType!=DATE) || (FieldData->FieldType!=LOGICAL)){
char Err6[256];
(void) sprintf(Err6, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err6);
return LPC_BAD_FIELD;
}
h->campo[i].fieldtype=(uint16_t) htons(h->campo[i].fieldtype);
h->campo[i].fieldtype=FieldData->FieldType;
h->campo[i].fieldlen=(uint16_t) htons(h->campo[i].fieldlen);
if((h->campo[i].fieldtype!=CHARACTER) || (h->campo[i].fieldtype!=NUMERIC) || (h->campo[i].fieldtype!=DATE) || (h->campo[i].fieldtype!=LOGICAL)){
char Err7[256];
(void) sprintf(Err7, "Valore di uno dei campi non valido: nome, tipo o lunghezza");
LPC_GestioneErrore(LPC_BAD_FIELD, "CreateDatabaseFile", Err7);
return LPC_BAD_FIELD;
}
if((h->campo[i].fieldtype==CHARACTER) && ((FieldData->FieldLen>=1) && (FieldData->FieldLen<=FIELD_CHAR_LEN)))
h->campo[i].fieldlen=FieldData->FieldLen;
if((h->campo[i].fieldtype==NUMERIC) && (FieldData->FieldLen<=FIELD_NUM_LEN))
h->campo[i].fieldlen=FieldData->FieldLen;
if((h->campo[i].fieldtype==DATE) && (FieldData->FieldLen<=FIELD_DATE_LEN))
h->campo[i].fieldlen=FieldData->FieldLen;
if((h->campo[i].fieldtype==LOGICAL) && (FieldData->FieldLen<=FIELD_LOGI_LEN))
h->campo[i].fieldlen=FieldData->FieldLen;
}
int ret=fwrite(h,sizeof(h),(size_t) h->dimHeader,fp);
if(ret!=h->dimHeader){
char Err9[256];
(void) sprintf(Err9, "Errore di scrittura su file");
LPC_GestioneErrore(LPC_ERR_WRITE, "CreateDatabaseFile", Err9);
return LPC_ERR_WRITE;
}
rename(Name,finale);
fclose(fp);
free(fp);
free(FieldData);
free(h);
free(Name);
return LPC_OK;
putchar('\n');
}


Mi passa tutti i test tranne questo. Praticamente mi va in Segmentation Fault, ma non capisco cosa mi sono dimenticato di allocare.

Grazie. :)