[C] errore in compilazione

[i_like_dobermann]

ciao a tutti, questo è il mio primo messaggio....
sto preparando un compito in c, e quando lancio il prog mi da questo errore:

preprocessor fatal error

line 1688, c:\include\winnt.h: #error: "undefined processor type"

non riesco a capire a cosa si riferisca....
chi può darmi una mano?....

[Ziosilvio]

Sembrerebbe che il tuo programma includa una parte che dipende dal tipo di processore; e che uno dei tipi che servono a te, non sia elencato nell'header winnt.h e non sia quindi usabile.

Per esserne sicuro, dovresti leggere il manuale del compilatore.

A proposito: se posti quale compilatore usi, e in che versione (esempio: Microsoft Visual C++ 6.0; oppure: Borland C++ 7.0), ti possiamo aiutare meglio.

[i_like_dobermann]

il primo problema l'ho risolto....
dovevo chiamare windowsx.h al posto di windows.h
xò poi mi esce questo:
line 44, c:\include\conio.h: #error: "Parse Error, expenting ")" o",""

il compilatore che uso è Miracle C

grazie

[Ubi-Wan]

Be, dovresti postare il pezzo di codice a cui si riferisce l'errore per capire di che si tratta.

[i_like_dobermann]

#ifndef __STRICT_ANSI__

#ifndef _CONIO_H_
#define _CONIO_H_

/* All the headers include this file. */
#include <_mingw.h>

#ifndef RC_INVOKED

#ifdef __cplusplus
extern "C" {
#endif


char* _cgets (char*);
int _cprintf (const char*, ...);
int _cputs (const char*);
int _cscanf (char*, ...);

int _getch (void);
int _getche (void);
int _kbhit (void);
int _putch (int);
int _ungetch (int);


#ifndef _NO_OLDNAMES

int getch (void);
int getche (void);
int kbhit (void);
int putch (int);
int ungetch (int);

#endif /* Not _NO_OLDNAMES */


#ifdef __cplusplus
}
#endif

#endif /* Not RC_INVOKED */

#endif /* Not _CONIO_H_ */

#endif /* Not __STRICT_ANSI__ */

[fantoibed]

Originariamente inviato da i_like_dobermann
xò poi mi esce questo:
line 44, c:\include\conio.h: #error: "Parse Error, expenting ")" o",""

Scritto così mi vien da pensare che l'errore venga generato a da una funzione polimorfa non correttamente riconosciuta... Il C non supporta il polimorfismo mentre il C++ sì. Prova a ricompilare il tuo programma come fosse in c++ e facci sapere...

Comunque è più giusto includere windows.h piuttosto che windowsx.h

Devi trovare il modo di dichiarare il processore su cui deve girare il codice che hai scritto, piuttosto. Per farlo dovresti leggere il manuale del tuo compilatore, perché mi pare che questo tipo di definizioni sia fuori standard... Prova/cerca qualcosa tipo:

#define WIN32
...o...
#define _WIN32_
...o analoghi....

Se non riesci prova ad usare il dev cpp che è gratuito, così possiamo supportarti meglio, anche se i compilatori gcc non rendono proprio al meglio con i programmi per windows...

[i_like_dobermann]

Codice PHP:

ho risolto il problema con il conio.h

xò ora mi esce questo:

c:\programmi\microsoft visual studio\vc98\include\hash.h(144) : fatal error C1004: unexpected end of file found
Find.c
c:\programmi\microsoft visual studio\vc98\include\hash.h(144) : fatal error C1004: unexpected end of file found
Error executing cl.exe.
vi posto i sorgenti di index.c, find.c e hash.h

xkè alla linea 144 di hash.h non c'è scritto nulla:muro: 

index.c

/***************************************************
*         Programma per indicizzare, tramite       *
*         l'aiuto del file hash.h                  *
*         la radice di Windows                     *
***************************************************/
#include <stdio.h>
#include <hash.h>

PATH=/windows:$PATH

// prototipi

void Report(clock_t tot);
void SalvaReport(char * argv);

/*Variabili ad utilizzo globale*/

t_vett vettore[MAX_VETT];


//main
void main(int argc,char * argv[])
{
    char path[MAX_PATH];
    int pos;
    clock_t start,stop;

    Attendere(argv[1]);
    start=clock();

    /*Controllo parametri argv[]*/
    if(argc<2) 
    {
        printf("\n\tUtilizzare:  index -path\n path:");
        printf("percorso radice della indicizzazione\n\n\n");
        exit(-1);
    }

    /*copia del path nella variabile path*/
    else 
    {
        strcpy(path,argv[1]);
        pos=strlen(path)-1;
        if(path[pos]!='\\')
        {
            strcat(path,"\\");
        }    
    }
    /****************************************************
    *        Inizializza la struttura vettore[]            *                                 *
    ****************************************************/
    
    InitStruttura(vettore);

    /****************************************************
    *        trova le directory ed al suo interno        *
    *       provvede a chiamare la InsertInStruct        *
    ****************************************************/
    
    TrovaDir(path);

    /****************************************************
    *        Funzione implementata per il controllo      * 
    *       della corretta indicizzazione delle parole    *
    ****************************************************/
    
    

    stop=clock();
    start=(stop-start)/CLOCKS_PER_SEC;
    Report(start);
    SalvaReport(argv[0]);
}


/* funzione che permette di salvare il risultato dell'operazione
 di indicizzazione*/

void SalvaReport(char * argv)
{

t_lista * ctrl_l;
t_lista * list;
t_vett * vect;
int i;
FILE *fp;
char file[MAX_PATH],view=0;
char * percorso,PathInd[MAX_PATH];

    printf("\n\n\nSi desidera salvare un report della struttura indicizzata? (Si/No): ");
    scanf("%c",&view);
    view=tolower(view);
    if(view=='s')
    {
        system("cls");
        printf("\n\tNome del file: ");
        fflush(stdin);
        gets(file);
        
        percorso=strstr(argv,"index.exe");
        *percorso=0;
        strcat(argv,file);

        fp=fopen(argv,"w");
        if(fp==NULL) 
        {
            printf("\nImpossibile aprire il file.");
            return;
        }
        GetCurrentDirectory(MAX_PATH,PathInd);
        fprintf(fp,"\n\t***  INDICIZZAZIONE CON RADICE = %s  ***\n\n",PathInd);

        for(i=0;i<MAX_VETT;i++)
        {
            if(vettore[i].flag==1)
            {
                fprintf(fp,"\n%s",vettore[i].word);
                ctrl_l=vettore[i].l_next;
                
                /*stampa percorsi*/
                
                while(ctrl_l!=NULL)
                {
                    fprintf(fp,"\n |-- %s",ctrl_l->path_name);
                    ctrl_l=ctrl_l->l_next;
                }


                /**************************************
                * controlla parole con lo stesso hash *
                **************************************/
                
                vect=vettore[i].v_next;
                while(vect!=NULL)
                {
                    fprintf(fp,"\n%s(hash)",vect->word);
                    
                    /*********************
                    *   stampa percorsi  *
                    *********************/
                    
                    list=vect->l_next;
                    while(list!=NULL)
                    {
                        fprintf(fp,"\n |-- %s",list->path_name);
                        list=list->l_next;
                    }
                    
                    vect=vect->v_next;
                }
            }
            
        }
        printf("\n\n  Salvataggio di\n\t %s\n\n\t concluso correttamente.\n",argv);
        fclose(fp);
    }
    else
    {
        printf("\n\n");
        return;
    }
}

void Report(clock_t tot)
{
time_t caltime;
    system("cls");
    time(&caltime);    
    printf("\t\t\t\t\t\t\t%s", ctime(&caltime));
    printf("\n\t\t ---------------------------------------------------");
    printf("\n\t\t |  E L A B O R A Z I O N E  C O M P L E T A T A   |");
    printf("\n\t\t ---------------------------------------------------");
    printf("\n\t\t Informazioni di elaborazione");
    printf("\n\t\t Totale directory analizzate: %d",directories);
    printf("\n\t\t Totale files analizzati: %d",files);
    printf("\n\t\t Tempo di esecuzione totale: %d secondi",tot);
    printf("\n\t\t Tempo medio di analisi per file: %.2f secondi",((float)tot)/files);
    printf("\n\t\t Tempo medio di analisi per directory: %.2f secondi\n\n",((float)tot)/directories);
    
}

/********************************************************************
*Apre il file, fa la hash di ogni parola e la posiziona in vettore  *
********************************************************************/

int estrapolaparole(char * file)
{
FILE * fp;
int pos=0,insert=0,j=0;
char * token="0",word[65535],DirCurr[MAX_PATH];
t_lista * list;
t_lista * tmp;
t_vett * vett;
t_vett * vetttmp;
t_vett * testa=vettore;
vett=&vettore;


    /*recupera la directory attuale*/
    GetCurrentDirectory(MAX_PATH,DirCurr);
    if(DirCurr[(strlen(DirCurr)-1)]!='\\')
        strcat(DirCurr,"\\");
    
    /*tenta di aprire il file*/
    fp=fopen(file,"r");

    if(fp==NULL) 
        return -1;

    files++;

    strcat(DirCurr,file);


            /***************************************************
            *         controlla le altre parole                *
            *         finche non ce ne sono +,                 *
            *         se la parola è troppo corta              *
            *         non la inserisce e va alla prossima, poi *
            *         calcola posizione in vettore con hash(); *
            *      se la struttura è piena...ne crea un altra  *
            ***************************************************/    
                    
    while(!feof(fp))
    {
        if(fscanf(fp,"%s",word)==EOF )
            return 3;
        
        token=strtok(word," \n\t");
        while(token!=NULL)
        {
            
            if(strlen(token)<4) goto NextWord;
            
            
            pos=hash(token,strlen(token));
            *vett=vettore+pos;
            

/***************************************************************            
*             gestione inserimento,                            *
*             se la parola non esiste in vettore               *
*             la inserisce,                                    *
*           allocazione nuova cella e linking alla struttura   *
*           copia il path nella nuova zona di memoria;         *
*           mette il flag che indica che la cella è piena      *
***************************************************************/

    PRIMOCICLO:
            while(insert==0)
            {
                if((*vett)->flag==0)
                {
                    strcpy((*vett)->word,token);
                    (*vett)->flag=1;
                    (*vett)->l_next=malloc(sizeof(t_lista));
                    strcpy(((*vett)->l_next)->path_name,DirCurr);  
                    ((*vett)->l_next)->flag=1;
                    ((*vett)->l_next)->l_next=NULL;
                    (*vett)->v_next=NULL;
                    insert=1;
                }
                /*******************************************
                * se la cella del vettore è piena e la     *
                * parola coincide cerca un elemento        * 
                * della lista vuoto                        *
                *******************************************/


                else if((*vett)->flag==1 && strcmp((*vett)->word,token)==0 )
                {
                    
                    list=(*vett)->l_next;
                    while(list!=NULL )
                    {
                        //la parola è ripetuta nello stesso file
                        if(strcmp(list->path_name,DirCurr)==0)
                        {
                            insert=1;
                            goto PRIMOCICLO;
                        }
                        tmp=list;
                        list=list->l_next;
                    }
                    list=tmp;
                    list->l_next=malloc(sizeof(t_lista));
                    list=list->l_next;
                    list->flag=1;
                    strcpy(list->path_name,DirCurr);
                    list->l_next=NULL;
                    insert=1;
                }

                else
                 /* se la cella è già occupata inserisce  *
                 *  elemento in lista con lo stesso hash */
                {
                    vetttmp=vett;
                    (*vett)=(*vett)->v_next;
                    while((*vett)!=NULL)   
                    {
                        //stessa parola in vettore
                        if(strcmp((*vett)->word,token))
                        {
                            list=(*vett)->l_next;
                            while(list!=NULL)
                            {    //stesso path
                                if(strcmp(list->path_name,DirCurr))
                                {
                                    insert=1;
                                    goto PRIMOCICLO;
                                }
                                tmp=list;
                                list=list->l_next;
                            }
                            list=tmp;
                            list->l_next=malloc(sizeof(t_lista));
                            list=list->l_next;
                            list->flag=1;
                            strcpy(list->path_name,DirCurr);
                            list->l_next=NULL;
                            insert=0;
                            goto NextWord;
                        }

                        vetttmp=vett;
                        (*vett)=(*vett)->v_next;
                    }
                    (*vett)=vetttmp;
                    //stesso hash ma non in vettore
                    (*vett)->v_next=malloc(sizeof(t_vett));
                    (*vett)=(*vett)->v_next;
                    (*vett)->flag=0;
                    continue;
                }
            }
            (*vett)=testa;
            insert=0;

NextWord:    token=strtok(NULL," \n\t");
        }
    }
    fclose(fp);
    return 1;
}
float InsertInStruct()
{
    WIN32_FIND_DATA Data;
    HANDLE Hfile;

    /*Cerca il primo txt*/
    Hfile=FindFirstFile("*.txt",&Data);
    if(Hfile==ERROR_FILE_NOT_FOUND)
    {
        return 1;
    }

    /***************************
    *    Estrapola primo file  *
    ***************************/
    
    if(!(estrapolaparole(Data.cFileName)))
    {
        printf("\nErrore sull'estrapolazione del file %s\nErrore: %d\n\n\n",
                  Data.cFileName,GetLastError());
        return(-3);
    }
    /***********************************
    *   Estrapola il resto dei file    *
    ***********************************/
    
    while(FindNextFile(Hfile,&Data))
    {
        if(!(estrapolaparole(Data.cFileName)) )
        {
        printf("\nErrore sull'estrapolazione del file %s\nErrore: %d\n\n\n",
                  Data.cFileName,GetLastError());
        return(-4);
        }
    }
    FindClose(Hfile);
    SetLastError(0);
    return 2;
} 


[i_like_dobermann]

Codice PHP:

#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <malloc.h>
#include <math.h>
#include <time.h>
#include <windows.h>

#define MAX_VETT 100000
#define MAX_DIR 1000

#define FILE_NOT FOUND -100



/**********************************
* Definizione di struttura per il *
* contenimento dei vari files     *
**********************************/

typedef struct lista {
        unsigned short flag;
        char path_name[MAX_PATH];
        struct lista * 1_next;
        } listfile;

/****************************************************************
* Definizione di una struttura per contenere le parole trovate, *
* che verranno linkate (mediante i propri puntatori)a strutture *
* di tipo listfile e della stessa tipologia                     *
****************************************************************/

typedef struct vett {
        unsigned short flag;
        char word [256];
        struct vett * v_next;
        listfile * l_next;
        } t_vett;

unsigned long files=0, directories=0;

int hash(char * word, int size)
  {
    int results=0, i;
    char * p=word;        
    for(i=1,i<=size,i++,p++)
     {
       results=results+ ((int)*p)*i;
       if (results>MAX_VETT) results/=2;
     }
    if results<=0;             /*viene considerato il modulo matematico 
                    in caso di ritorno di un numero negativo*/
       { results=(int)sqrt*ris*ris);
       }
    
    return results;
   }

void InizioStruttura(t_vett * p_vett)
     {                               
     unsigned int i;                 
     for (i=0,i<MAX_VETT,i++)        
         {
         p_vett->flag=0;  
         p_vett->v_next=NULL;
         p_vett->l_next=NULL;
         p_vett++;
         }
     }
  
void ATTESA(char * path)//funzione di attesa per il caricamento dei dati
     {
     time_t caltime;
     
       system("cls");
       time(&caltime);
       printf("\t\t%s\n", ctime(&caltime);
       printf("\tATTENDERE PREGO\t\n"
              "\tAnalisi albero \t\n"
              "\tper ricerca e indicizzazione\n"
              "di tutti i file con estensione txt\n");
     }

int cercaPath(char * path);
{
 int errore;
            errore=SetCurrentDirectory(path);
            if(!errore)
            {
            printf("Percorso %s non valido,\n Errore %d\n",path,GetLastError());
            return (-1);
            }
            else return 0;
}

void TrovaDirectory(char path[])
{
HANDLE HDir;
WIN32_FIND_DATA Dir;

DWORD error;
int i;
      directories++;
      
      cercaPath(path);
      
      if(!InsertInStruct())
      {
        printf("warning"\n);
        return
      }

      HDir=FindFirstFile("*..",&Dir);
      
      for(i=0,Dir.cFileName[0]=='.',i++)
      {
        FindNextFile(HDir,&Dir);
        if(i>1)
        return;
      }
      
      error=GetLastError();
      
      /*scorre fino all'ultimo file trovato*/
      while(error!ERROR_NO_MORE_FILES)
      {
        if(Dir.dwFileAttributes==FILE_ATTRIBUTE_DIRECTORY)
        {
           TrovaDirectory(Dir.cFileName);
           SetCurrentDirectory("..");
           SetLastError(1);
           FindNextFile(Hdir,&Dir);
           error=GetLastError();
        }
        else
        {
           SetLastError(1);
           FindNextFile(HDir,&Dir);
           error=GetLastError();
        }
      }
      FindClose(HDir);
} 


[i_like_dobermann]

Codice PHP:

/*****************************************************
*                            Find.c                            
*  Programma per eseguire la ricerca di un parola contenuta all'interno di un                                                                                  *
*  file txt incluso nell'albero della radice di windows, e restituisce il       *
*  numero dei file trovati                                                       *
*                                                                                *
********************************************************************************/


#include <stdio.h>
#include <hash.h>
    
    
    //  prototipi 

void Report(clock_t tot);
int ParolaCercata(char * file);

    //Variabili ad utilizzo globale

char parola[256];
t_vett * vett;

void main(int argc,char * argv[])
{
    char path[MAX_PATH];
    int posizione;
    clock_t start,stop;


    vett=NULL;

    //Controllo i parametri passati al programma
    if(argc<3) 
    {
        printf("Utilizzare:  find -path -parola\n"
               "Path: percorso della radice\n"
               "parola: parola da cercare\n");
        exit(-1);
    }//fine if

/* Preparazione dell'elaborazione per la copia dei parametri passati, start del contatore per le statistiche*/
    else 
    {
        Attendere(argv[1]);
        start=clock();
        
        strcpy(parola,argv[2]);
        strcpy(path,argv[1]);
        pos=strlen(path)-1;
        if(path[pos]!='\\')
        {
            strcat(path,"\\");
        }    //fine if
    }//fine else

    TrovaDir(path);//trova le directories

    stop=clock();//stop alle statistiche, conteggio del tempo di ricerca e stampata dell'output prodotto
    start=(stop-start)/CLOCKS_PER_SEC;
    Report(start);
}

/*********************************************
*    Funzione che stampa il risultato dell'elaborazione   *
*********************************************/
void RitornoDato(clock_t tot)
{
time_t caltime;
t_lista * list;

    system("cls");
    time(&caltime);    
    printf("\t\t\t%s\n\n", ctime(&caltime));
    printf(" Calcolo Completato\n\n");
    printf(" Informazioni dell' elaborazione\n\n");
    printf(" Totale directories analizzate: %d\n\n",directories);
    printf(" Totale files analizzati: %d\n\n",files);
    printf(" Tempo di esecuzione totale: %d secondi",tot);
    printf(" Tempo medio di analisi per file: %.2f secondi\n\n",((float)tot)/files);
    printf(" Tempo medio di analisi per directories: %.2f secondi\n\n",((float)tot)/directories);
    printf(" Premere un tasto per visualizzare le occorrenze trovate.\n\n");
    getch();
    system("cls");
    lst=vett->l_next;
    printf(" La parola %s e' stata trovata nei seguenti file: \n",vett->word);

    while(lst!=NULL)
    {
        printf("\n- %s",list->path_name);
        list=list->l_next;
    }//fine while
}

 /******************************************************
* La funzione ParolaCercata esegue la ricerca della parola rihiesta dall'utente 
* all'interno di un file, passato sotto forma di stringa dalla funzione chiamante 
*******************************************************/
int ParolaCercata(char * file)
{
FILE * fp;
int posizione=0,insert=0,j=0;
char * token="0",word[65535],DirCurr[MAX_PATH];
t_lista * list,* tmp;


    //Recupera la directory attuale e la copia nella variabile DirCurr
    GetCurrentDirectory(MAX_PATH,DirCurr);
    if(DirCurr[(strlen(DirCurr)-1)]!='\\')
        strcat(DirCurr,"\\");
    
    //tenta di aprire il file
    fp=fopen(file,"r");

    //Analizza la presenza di errori
    if(fp==NULL) 
        return FILE_NOT_FOUND;
    
    files++;
    strcat(DirCurr,file);

    // Lettura delle parole da file 
    while(!feof(fp))
    {
        if(fscanf(fp,"%s",word)==EOF )
            return 3;
        
        token=strtok(word," \n\t");
        while(token!=NULL)
        {
            if(strcmp(token,parola)==0)
            {
                //inserimento
                if(vett==NULL)
                {
                    //Inserimento della prima occorrenza
                    vett=malloc(sizeof(t_vett));
                    if(vett==NULL) return -2;

                    vett->flag=1;
                    vett->v_next=NULL;
                    strcpy(vett->word,parola);

                    //inserimento del percorso

                                        vett->l_next=malloc(sizeof(t_lista));
                    list=vett->l_next;
                    list->flag=1;
                    strcpy(list->path_name,DirCurr);
                    list->l_next=NULL;
                    
                }//fine if
                else
                {
                    //Inserimento di N-1 occorrenze
                    //con N numero delle occorrenza trovate
                    list=vett->l_next;
                    while(list!=NULL)
                    {
                        if(strcmp(list->path_name,DirCurr)==0) 
                            goto NextToken;
                        
                        tmp=list;
                        list=list->l_next;
                    }//fine while
                    list=tmp;
                    list->l_next=malloc(sizeof(t_vett));
                    list=list->l_next;
                    list->flag=1;
                    strcpy(list->path_name,DirCurr);
                    list->l_next=NULL;
                }//fine else

            }//fine if
NextToken:            token=strtok(NULL," \n\t");
        }//fine while
    }//fine while
    
    fclose(fp);
    return 1;
}



int InsertInStruct() 
{
    WIN32_FIND_DATA Data;
    HANDLE Hfile;

    //Ricerca del primo file txt
    Hfile=FindFirstFile("*.txt",&Data);
    if(Hfile==ERROR_FILE_NOT_FOUND)
    {
        return 1;
    }

        //Estrapola primo file
    if(!(ParolaCercata(Data.cFileName)))
    {
        printf("\nErrore sull'estrapolazione del file %s\nErrore: %d\n\n\n",Data.cFileName,GetLastError());
        return(-3);
    }
    
    //Estrapola il resto dei file
    while(FindNextFile(Hfile,&Data))
    {
        if(!(ParolaCercata(Data.cFileName)) )
        {
        printf("\nErrore sull'estrapolazione del file %s\nErrore: %d\n",Data.cFileName,GetLastError());
        return(-4);
        }//fine if
    }//fine while
    FindClose(Hfile);
    SetLastError(0);
    return 2;
} 


[i_like_dobermann]

come compilatore sto provando il visual c

[RaouL_BennetH]

Originariamente inviato da i_like_dobermann

xò poi mi esce questo:
line 44, c:\include\conio.h: #error: "Parse Error, expenting ")" o",""

il compilatore che uso è Miracle C

grazie

scusate, ma un "Parse error", in genere non è un semplice errore di sintassi?

Vedendo poi:

expeting ")" o ", "...mi vien da pensare a qualche parentesi dimenticata oppure, più probabilmente a qualche virgoletta non chiusa.

[i_like_dobermann]

effettivamente è così,
li il problema è stato risolto, mancava un ";" a dir la verità

[fantoibed]

Per favore, potresti modificare i post inserendo [ PHP] e [ /PHP] prima e dopo i sorgenti, altrimenti si perde l'indentazione ed è difficile seguire l'andamento del programma, soprattutto per quanto riguarda le parentesi . So che il programma è in C e non in php, ma c e php hanno molte similitudini ed il syntax hilighting lo evidenzia in modo, tutto sommato accettabile....

Per ora posso solo consigliarti di controllare bene le parentesi.
Spesso io, per rendere più leggibile il codice commento anche in questo modo:

Codice PHP:

if (bla bla bla)
{
    bla bla;
    while (bla bla)
    {
        bla bla bla bla;
    }; // fine while (bla bla)
}; //fine if (bla bla bla) 


Facendo così riesco a capire meglio a che parentesi aperta si riferisce ogni parentesi chiusa.... Non è che ti chiedo di far questo, semplicemente io mi trovo bene a programmare commentando in questo modo e te lo consiglio: si rende più leggibile il sorgente...

In ogni caso ti consiglio di controllare bene le parentesi....
Se ho un po' di tempo proverò a darti una mano...

[i_like_dobermann]

Originariamente inviato da fantoibed
Per favore, potresti modificare i post inserendo [ PHP] e [ /PHP] prima e dopo i sorgenti, altrimenti si perde l'indentazione ed è difficile seguire l'andamento del programma, soprattutto per quanto riguarda le parentesi . So che il programma è in C e non in php, ma c e php hanno molte similitudini ed il syntax hilighting lo evidenzia in modo, tutto sommato accettabile....

Per ora posso solo consigliarti di controllare bene le parentesi.
Spesso io, per rendere più leggibile il codice commento anche in questo modo:

Codice PHP:

if (bla bla bla)
{
    bla bla;
    while (bla bla)
    {
        bla bla bla bla;
    }; // fine while (bla bla)
}; //fine if (bla bla bla) 


Facendo così riesco a capire meglio a che parentesi aperta si riferisce ogni parentesi chiusa.... Non è che ti chiedo di far questo, semplicemente io mi trovo bene a programmare commentando in questo modo e te lo consiglio: si rende più leggibile il sorgente...

In ogni caso ti consiglio di controllare bene le parentesi....
Se ho un po' di tempo proverò a darti una mano...

php inserito....
grazie dei consigli