[C] Mantenere valore tra le funzioni

[Manugal]

Il fatto è che non mostro tutto il codice perché poi ti girerebbe ancora di più la testa. Cmq se vuoi ti posto il codice completo delle due funzioni.

#include "LPC_Include.h"
#include "LPC_M2_Include.h"
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

int OpenDatabaseFile (char *Name){
   int numerorecords;
   int test;
   char *filename;
   char *filenameopen;
   if((Name==NULL) || (cercaErr(Name))){
       char Err[256];
       (void) sprintf(Err, "Nome DB nullo o non valido");
       LPC_GestioneErrore(LPC_BAD_ARG, "OpenDatabaseFile", Err);
       return LPC_BAD_ARG;
    }
   if(strlen(Name)>=DBF_NAME_LENGTH)
       Name[DBF_NAME_LENGTH+1]='\0';
   filename=(char *)malloc(sizeof(char)*DBF_FILENAME_LENGTH);
   sprintf(filename,"%s%s", Name, DBF_EXTENSION);
   if(filename==NULL){
      char Err[256];
      (void) sprintf(Err, "Errore di allocazione memoria");
      LPC_GestioneErrore(LPC_NO_MEMORY, "OpenDatabaseFile", Err);
      return LPC_NO_MEMORY;
   }
   if(access(filename,F_OK)!=0){
      char Err[256];
      (void) sprintf(Err, "File non esistente o non accessibile");
      LPC_GestioneErrore(LPC_FILE_ACCESS, "OpenDatabaseFile", Err);
      if(filename!=NULL)
         free(filename);
      return LPC_FILE_ACCESS;
   }
   filenameopen=(char *)malloc(sizeof(char)*DBF_FILENAME_LENGTH);
   sprintf(filenameopen,"%s%s", Name, DBF_OPEN_EXT);
   if(filenameopen==NULL){
      char Err[256];
      (void) sprintf(Err, "Errore di allocazione memoria");
      LPC_GestioneErrore(LPC_NO_MEMORY, "OpenDatabaseFile", Err);
      if(filenameopen!=NULL)
         free(filenameopen);
      if(filename!=NULL)
         free(filename);
      return LPC_NO_MEMORY;
   }
   if(access(filenameopen,F_OK)==0){
      char Err[256];
      (void) sprintf(Err, "DBF già aperto");
      LPC_GestioneErrore(LPC_DBF_OPEN, "OpenDatabaseFile", Err);
      if(filenameopen!=NULL)
         free(filenameopen);
      if(filename!=NULL)
         free(filename);
      return LPC_DBF_OPEN;
   }
   cntOpenDatabases++;
   if(cntOpenDatabases>MAX_DBF_OPEN){
      char Err[256];
      (void) sprintf(Err, "Massimo numero di DBF aperti");
      LPC_GestioneErrore(LPC_NO_SPACE, "OpenDatabaseFile", Err);
      cntOpenDatabases=-1;
      if(filenameopen!=NULL)
         free(filenameopen);
      if(filename!=NULL)
         free(filename);
      return LPC_NO_SPACE;
   }
   FILE *fp=fopen(filename,"rb+");
   FILE *fpopen=fopen(filenameopen,"wb+");
   if(fp==NULL || fpopen==NULL){
      char Err[256];
      (void) sprintf(Err, "Errore di allocazione memoria");
      LPC_GestioneErrore(LPC_NO_MEMORY, "OpenDatabaseFile", Err);
      if(filenameopen!=NULL){
         remove(filenameopen);
         free(filenameopen);
      }
      if(filename!=NULL)
         free(filename);
      return LPC_NO_MEMORY;
   }
   fclose(fpopen);
   test=fseek(fp, sizeof(header)+1, SEEK_SET);
   if(test!=0){
      char Err[256];
      (void) sprintf(Err, "Errore di spostamento su file");
      LPC_GestioneErrore(LPC_ERR_SEEK, "OpenDatabaseFile", Err);
      rewind(fp);
      if(filenameopen!=NULL){
         remove(filenameopen);
         free(filenameopen);
      }
      if(filename!=NULL)
         free(filename);
      return LPC_ERR_SEEK;
   }
   int i;
   for(i=0; i<=MAX_DBF_OPEN; ++i)
      if(ihndl[i].fp==NULL){
         ihndl[i].h=cntOpenDatabases;
         ihndl[i].currentRec=1;
         ihndl[i].fp=fp;
         sprintf(ihndl[i].name, "%s", Name);
         break;
      }
   free(filenameopen);
   free(filename);
   return cntOpenDatabases;
}

int CloseDatabaseFile (int handle){
    int test;
    char *opennamefile;
    opennamefile=(char *)malloc(sizeof(char)*DBF_FILENAME_LENGTH);
    if(opennamefile==NULL){
       char Err[256];
       (void) sprintf(Err, "Errore di allocazione memoria");
       LPC_GestioneErrore(LPC_NO_MEMORY, "CloseDatabaseFile", Err);
       return LPC_NO_MEMORY;
    }
    sprintf(opennamefile, "%s%s", ihndl[handle].name, DBF_OPEN_EXT);
    if(ihndl[handle].h!=handle){
       char Err[256];
       (void) sprintf(Err, "Handle non valido");
       LPC_GestioneErrore(LPC_BAD_ARG, "CloseDatabaseFile", Err);
       return LPC_BAD_ARG;
    }
    test=fclose(ihndl[handle].fp);
    if(test!=0){
       char Err[256];
       (void) sprintf(Err, "Errore di chiusura file");
       LPC_GestioneErrore(LPC_FILE_ACCESS, "CloseDatabaseFile", Err);
       return LPC_FILE_ACCESS;
    }
    remove(opennamefile);
    ihndl[handle].fp=NULL;
    ihndl[handle].h=-1;
    ihndl[handle].currentRec=-1;
    --cntOpenDatabases;
    return LPC_OK;
    putchar('\n');
}

Le funzioni si trovano in due files separati.
Quella variabile cntOpenDatabases è dichiarata come static in un file .h incluso da entrambe le funzioni ed è inizializzata a -1. A me questa variabile serve perché mi conta i databases che sono stati aperti, però nel momento in cui ne chiudo uno il valore di questa variabile deve diminuire di 1. Il problema (cioè non è un vero e proprio problema perché una variabile static si comporta così) che si presenta è che se chiamo la OpenDatabaseFile il valore di cntOpenDatabases va a 0 (perché questa funzione lo incrementa). Subito dopo chiamo CloseDatabaseFile e questa funzione mi decrementa questa variabile. Ora se io richiamo OpenDatabaseFile il valore di quella variabile, dopo l'incremento, è 1, mentre io voglio che sia 0 (perché è stata decrementata da CloseDatabaseFile). Spero di essere stato chiaro.