TParserScomponi.cpp

Go to the documentation of this file.

#include "../../include/Parser/TParserScomponi.h"

//**************************************************************************
/*
  * Nome funzione:     Libera_Memoria
  * Parametri:         vettore_riferimenti:  struttura contenente il la funzione scomposta
                                             da deallocare

  * Valori di ritorno: nessuno
  * Descrizione:       quando richiamata libera la memoria precedentemente occupata
                       dalla struttura dati
*/
//**************************************************************************

void TParserScomponi::Libera_Memoria(rif* vettore_riferimenti)
 { int indice_rif,indice_scomp,i;
 for (indice_rif=1;indice_rif<=vettore_riferimenti->numero_scomposizioni;indice_rif++)
  {
    for (indice_scomp=1;indice_scomp<=(vettore_riferimenti+indice_rif-1)->lunghezza_scomp;indice_scomp++)
     {
       i=0;                     //Mi occupo di svuotare la matrice
      while(i<(((vettore_riferimenti+indice_rif-1)->scomposizioni)+indice_scomp-1)->n_colonne)
        {   free(*((((vettore_riferimenti+indice_rif-1)->scomposizioni)+indice_scomp-1)->scomposizione+i));
           i++;
        }

      free((((vettore_riferimenti+indice_rif-1)->scomposizioni)+indice_scomp-1)->scomposizione);

     }

      free((vettore_riferimenti+indice_rif-1)->scomposizioni);
      free((vettore_riferimenti+indice_rif-1)->descrizione);
  }
  free(vettore_riferimenti);
}






 //--------------sub che gestisce un eventuale assegnazione------------------
/*
  * Nome funzione:     Gestione_assegnazione
  * Parametri:         funzione   stringa che contiene l'espressione presa in
                                  input
                       errore    0  Š presente almeno 1 errore nella stringa
                                     di assegnazione
                                 1  non Š presente nessun errore nella stringa
                                    di assegnazione
  * Valori di ritorno:           1  Š stata effettuata un assegnazione
                                 0  non Š stata effettuata un assegnazione
  * Descrizione:      funzione che rileva all'interno dell'espressione
                      matematica un eventuale stringa di assegnazione
                      (f(x):=sin(x) la stringa di assegnazione Š = f(x)),
                      ne effettua ad un controllo della sintassi e salva le
                      variabili in una opportuna struttura dati
*/
//**************************************************************************


int TParserScomponi::Gestione_assegnazione(char* funzione,int* errore,int* n_variabili)
{
   int posizione_assegnazione; //Individua se viene effettuata una assegnazione
   int i; //Variabile contatore
   int cont_variabili; //Conta il numero di variabili
   char str_assegnazione[150];//Stringa di assegnazione antecedente :=
   int parentesi_apri=0; //Contiene la posizione del carattere (
   int parentesi_chiudi=0;//Contiene la posizione del carattere )
   int posizione_virgola;//Contiene la posizione del carattere ,
   int posizione_start;//Posizione di partenza
   int len_assegn; //Contiene la lunghezza di str_assegnazione

//Cerco il carattere che definisce un assegnazione
   posizione_assegnazione = Instr(1, funzione, ":=");
//inizializzo le variabili (errore=1 nessun errore;errore=0 rilevato errore di sintassi)
   *errore = 1;
   i = 0;
 if (posizione_assegnazione > 0)//se esiste una stringa di assegnazione
//controllo sulla sintassi dell'assegnazione
  { Mid(str_assegnazione,funzione, 1, posizione_assegnazione - 1); //TAGLIO VIA L'ASSEGNAZIONE
     len_assegn=Len(str_assegnazione);
//Cicla finchŠ non trova errori e finchŠ i Š < della lunghezza della stringa)
   while ((*errore == 1)&&(i < len_assegn))
     {  //Controllo carattere per carattere di str_assegnazione
      if ((str_assegnazione[i] < 'A') || (str_assegnazione[i] > 'z'))
         {if ((str_assegnazione[i] != '(') && (str_assegnazione[i] != ')') && (str_assegnazione[i] != ','))
      // se non Š una lettere,una parentesi o una virgola (caratteri ammessi)
           errore = 0;//Š errore
          else //altrimenti
          { if (str_assegnazione[i] == '(')//se Š una apertura parentesi
             parentesi_apri++;
            else
             { if (str_assegnazione[i] == ')')//se Š una chiusura parentesi
                parentesi_chiudi++;
               if (i > 1)//se mi trovo almeno sul secondo elemento della stringa
                {       //controllo che non vi siano due virgole consecutive
                  if ((str_assegnazione[i-1]== ',') && (str_assegnazione[i] == ','))
                   errore = 0; //se si Š errore
                }
             }
      //Nella stringa di assegnazione sono ammessi al massimo una ( e una )
             if ((parentesi_chiudi > 1) || (parentesi_apri > 1))
               errore = 0;
          }
         }
     //Incremento l'indice che rappresenta la posizione attuale nella stringa
      i = i + 1;
     }
 // --------------FINE CICLO CONTROLLO-------------
    if (parentesi_chiudi != parentesi_apri)
       errore = 0; //Se il numero di ( Š diverso dal numero di )

    if (*errore == 1)//Se per il momento non sono stati rilevati errori
  //SE SI TRATTA DI UNA FUNZIONE CONTROLLO CHE ) SIA EFFETTIVAMENTE L'ULTIMO CARATTERE
     {if (((Instr(1, str_assegnazione, "(")) > 1) && ((Instr(1, str_assegnazione, ")")) < Len(str_assegnazione)))
       errore = 0;
     }
// Fine controllo sulla sintassi dell'assegnazione

    if (*errore == 1)
     {    cont_variabili = 0;
      if (Instr(1, str_assegnazione, "(") > 1)
         { //Se si tratta di funzione allora devo ottenerne le variabili
           posizione_virgola = Instr(1, str_assegnazione, ",");
           posizione_start = Instr(1, str_assegnazione, "(");
           cont_variabili = 1; //Di sicuro a questo punto vi Š almeno una variabile
          while (posizione_virgola > 0)//Conto il numero di variabili per il cast
           { //Sfrutto il numero di virgole per contare le variabili
             posizione_start = posizione_virgola;
            //Cerco la virgola nella stringa
             posizione_virgola = Instr(posizione_virgola + 1, str_assegnazione, ",");
           //Incremento il numero di variabili
             cont_variabili = cont_variabili + 1;
           }
     //Eseguo il cast del puntatore variabili in relazione al numero di variabili
             variabili=(variab*)malloc(sizeof(variab)*cont_variabili);
             posizione_virgola = Instr(1, str_assegnazione, ",");
             posizione_start = Instr(1, str_assegnazione, "(");
        //Salvo le variabili nella struttura
          for (i=0;i<cont_variabili-1;i++)
           {
         //copio dalla funzione di assegnazione la variabile nella struttura
            (variabili+i)->variabile=(char*)malloc(sizeof(char)*(posizione_virgola - posizione_start ));
            Mid((variabili+i)->variabile,str_assegnazione, posizione_start+1 , posizione_virgola - posizione_start - 1);
            posizione_start = posizione_virgola;
            posizione_virgola = Instr(posizione_virgola + 1, str_assegnazione, ",");
           }
            (variabili+i)->variabile=(char*)malloc(sizeof(char)*(Len(str_assegnazione) - posizione_start ));
            Mid((variabili+i)->variabile,str_assegnazione, posizione_start + 1, Len(str_assegnazione) - posizione_start - 1);

         }
          //Salvo il numero di variabili in una variabile globale
            *n_variabili = cont_variabili;
            return(1);
     }
  }

 return(0);
}
//**************************************************************************

/*
  * Nome funzione:     Lcase
  * Parametri:         funzione   stringa che contiene l'espressione presa in
                                  input

  * Valori di ritorno: void (nessuno)
  * Descrizione:questa funzione interpreta le funzioni matematiche
                fondamentali(sin,cos,ecc) e semplicemente le riscrive
                con una sintassi corretta(sin diventa Sin,cos diventa Cos,ecc)
*/

//**************************************************************************

void TParserScomponi::Lcase(char* funzione) //Riscrive adeguatamente alcune parti della
{                          //funzione

  int lunghezza,i,j;
  lunghezza=Len(funzione);
  char funzione_temp[3];
 for(i=0;i<lunghezza;i++)//Cicla per tutta la stringa
  {
  //se Š presente sin scritto come sin oppure sIn oppure sIN,ecc lo reimposta
 //adeguatemente cioŠ Sin
    Mid(funzione_temp,funzione,i+2,2);
    if(((funzione[i]=='s')||(funzione[i]=='S')) && ((strcmp(funzione_temp,"in")==0)||(strcmp(funzione_temp,"In")==0)||(strcmp(funzione_temp,"iN")==0)||(strcmp(funzione_temp,"IN")==0)))
     {
      if(funzione[i]>'Z')   //Se il primo carattere Š minuscolo
         funzione[i]=funzione[i]-32; //ne modifico il cod Ascii per ottenerlo maiuscolo
       for(j=1;j<=2;j++)//Se gli altri due caratteri sono maiuscoli allora
        {if(funzione[i+j]<'a')//gli imposto minuscoli
         funzione[i+j]=funzione[i+j]+32;
        }
        i=i+2;
           Mid(funzione_temp,funzione,i+2,2);

     }
//Medesima descrizione vista per il seno applicata al coseno
    if(((funzione[i]=='c')||(funzione[i]=='C')) && ((strcmp(funzione_temp,"os")==0)||(strcmp(funzione_temp,"Os")==0)||(strcmp(funzione_temp,"oS")==0)||(strcmp(funzione_temp,"OS")==0)))
     {
      if(funzione[i]>'Z')
         funzione[i]=funzione[i]-32;
       for(j=1;j<=2;j++)
        {if(funzione[i+j]<'a')
         funzione[i+j]=funzione[i+j]+32;
        }
        i=i+2;
           Mid(funzione_temp,funzione,i+2,2);

     }
//Medesima descrizione vista per il seno applicata all'abs
    if(((funzione[i]=='a')||(funzione[i]=='A')) && ((strcmp(funzione_temp,"bs")==0)||(strcmp(funzione_temp,"Bs")==0)||(strcmp(funzione_temp,"bS")==0)||(strcmp(funzione_temp,"BS")==0)))
     {
      if(funzione[i]>'Z')
         funzione[i]=funzione[i]-32;
       for(j=1;j<=2;j++)
        {if(funzione[i+j]<'a')
         funzione[i+j]=funzione[i+j]+32;
        }
        i=i+2;
           Mid(funzione_temp,funzione,i+2,2);

     }

        //Medesima descrizione vista per il seno applicata alla tangente
    if(((funzione[i]=='t')||(funzione[i]=='T')) && ((strcmp(funzione_temp,"an")==0)||(strcmp(funzione_temp,"An")==0)||(strcmp(funzione_temp,"aN")==0)||(strcmp(funzione_temp,"AN")==0)))
     {
      if(funzione[i]>'Z')
         funzione[i]=funzione[i]-32;
       for(j=1;j<=2;j++)
        {if(funzione[i+j]<'a')
         funzione[i+j]=funzione[i+j]+32;
        }
        i=i+2;
        Mid(funzione_temp,funzione,i+2,2);

     }
 //Medesima descrizione vista per il seno applicata al log
    if(((funzione[i]=='l')||(funzione[i]=='L')) && ((strcmp(funzione_temp,"og")==0)||(strcmp(funzione_temp,"Og")==0)||(strcmp(funzione_temp,"oG")==0)||(strcmp(funzione_temp,"OG")==0)))
     {
      if(funzione[i]>'Z')
         funzione[i]=funzione[i]-32;
       for(j=1;j<=2;j++)
        {if(funzione[i+j]<'a')
         funzione[i+j]=funzione[i+j]+32;
        }
        i=i+2;
           Mid(funzione_temp,funzione,i+2,2);

     }
 //Medesima descrizione vista per il seno applicata all'esponenziale
    if(((funzione[i]=='e')||(funzione[i]=='E')) && ((strcmp(funzione_temp,"xp")==0)||(strcmp(funzione_temp,"Xp")==0)||(strcmp(funzione_temp,"xP")==0)||(strcmp(funzione_temp,"XP")==0)))
     {
      if(funzione[i]>'Z')
         funzione[i]=funzione[i]-32;
       for(j=1;j<=2;j++)
        {if(funzione[i+j]<'a')
         funzione[i+j]=funzione[i+j]+32;
        }
        i=i+2;
     }
 //Medesima descrizione vista per il seno applicata al logaritmo naturale
     if(((funzione[i]=='l')||(funzione[i]=='L')) && ((funzione[i+1]=='n')||(funzione[i+1]=='N')))
     {
      if(funzione[i]>'Z')
         funzione[i]=funzione[i]-32;

        if(funzione[i+1]<'a')
         funzione[i+1]=funzione[i+j]+32;

        i=i+1;
     }


  }
}
//**************************************************************************

/*
  * Nome funzione:     Gestione_assegnazione
  * Parametri:         funzione   stringa che contiene l'espressione presa in
                                  input
  * Valori di ritorno:           1  non Š presente nessun errore di sintassi
                                    nell'espressione
                                 0  Š presente almeno un errore
  * Descrizione:      funzione che esegue un controllo della sintassi della
                      espressione presa in input
*/
//**************************************************************************

int TParserScomponi::Controllo_sintassi(char* funzione)
{
 int i;
 int parentesi_apri=0;
 int  parentesi_chiudi=0;
 int var_ok;
 int lunghezza=Len(funzione);
 char funzione_temp[5];
  if(lunghezza==0)//Se l'utente non inserisce niente è errore
   return(0);
  for (i=0;i<lunghezza;i++)   //ciclo che conta il numero di parentesi aperte e chiuse
   { if (funzione[i]=='(')
      parentesi_apri++;
     else
     {if (funzione[i]==')')
       parentesi_chiudi++;
     }
   }
  if(parentesi_chiudi!=parentesi_apri)
   return(0);
             i=0;
    while (i < lunghezza)  //CONTROLLO DEGLI OPERATORI ARITMETICI
     { if ((funzione[i] == '+') || (funzione[i] == '-') || (funzione[i] ==  '*') || (funzione[i] == '/') || (funzione[i] == '^'))
        { if (i > 1)
           { switch (funzione[i])
             { case '-':
                {if ( (funzione[i-1] == '+')||(funzione[i-1] == '-'))
                  return(0);
                  break;
                }
               case '+':
                {if  ((funzione[i-1] == '+')||(funzione[i-1] == '-'))
                  return(0);
                  break;
                }
               case '*':
                {if  ((funzione[i-1] == '+') || (funzione[i-1] == '-') || (funzione[i-1] == '*') || (funzione[i-1] == '/') || (funzione[i-1] == '^'))
                  return(0);
                  break;
                }
               case '/':
                {if  ((funzione[i-1] == '+') || (funzione[i-1] == '-') || (funzione[i-1] == '*') || (funzione[i-1] == '/') || (funzione[i-1] == '^'))
                  return(0);
                  break;
                }
               case '^':
                {if  ((funzione[i-1] == '+') || (funzione[i-1] == '-') || (funzione[i-1] == '*') || (funzione[i-1] == '/') || (funzione[i-1] == '^'))
                  return(0);
                  break;
                }
             }
                 if ((funzione[i-1] == '(') && ((funzione[i] == '*') || (funzione[i] == '/') || (funzione[i] =='^')))
                  return(0);
           }
          if (i < lunghezza-1)
           { switch (funzione[i])
             { case '-':
                { if ((funzione[i+1]== '+') || (funzione[i+1]== '-') || (funzione[i+1]== '*') || (funzione[i+1]== '/'))
                    return(0);
                    break;
                }
               case '+':
                { if ((funzione[i+1]== '+') || (funzione[i+1]== '-') || (funzione[i+1]== '*') || (funzione[i+1]== '/'))
                    return(0);
                    break;
                }
               case '*':
                { if ((funzione[i+1] == '*') || (funzione[i+1] == '/') || (funzione[i+1] == '^'))
                   return(0);
                   break;
                }
               case '/':
                { if ((funzione[i+1] == '*') || (funzione[i+1] == '/') || (funzione[i+1] == '^'))
                   return(0);
                   break;
                }
               case '^':
                { if ((funzione[i+1] == '*') || (funzione[i+1] == '/') || (funzione[i+1] == '^'))
                   return(0);
                   break;
                }
             }
            if (funzione[i+1] == ')')  //controllo se davanti ad un segno vi è )
              return(0);
           } else
              return(0);//se l'ultimo carattere Š un segno Š errore
        } else
           { if ((funzione[i] >= 'A') && (funzione[i] <= 'z'))
              {   var_ok = 0;
                 if(funzione[i]=='[')
                  var_ok=1;
               switch(funzione[i])  //CONTROLLO LA CORRETTA SINTASSI DELLE VARIE FUNZIONI ESEMPIO FUNZIONANTE
                  {  case 'A':
                   { Mid(funzione_temp,funzione, i+2, 2);
                    if ((strcmp(funzione_temp, "bs")!=0) && (var_ok == 0))
                      return(0);
                    else
                     { if (strcmp(funzione_temp,"bs")==0)
                        i = i + 3;
                       else
                        { if (var_ok == 1)
                           i = Instr(i+1,funzione,"]") - 1;
                        }
                     }
                    break;
                   }
                   case 'S':
                   { Mid(funzione_temp,funzione, i+2, 3);
                    if ((strcmp(funzione_temp, "in(")!=0) && (var_ok == 0))
                      return(0);
                    else
                     { if (strcmp(funzione_temp,"in(")==0)
                        i = i + 3;
                       else
                        { if (var_ok == 1)
                           i = Instr(i+1,funzione,"]") - 1;
                        }
                     }
                    break;
                   }
                                  //CONTROLLO SE E' UN COS

                  case 'C':
                   {Mid(funzione_temp,funzione, i+2, 3);
                    if ((strcmp(funzione_temp, "os(")!=0) && (var_ok == 0))
                      return(0);
                    else
                     { if (strcmp(funzione_temp,"os(")==0)
                        i = i + 3;
                       else
                        { if (var_ok == 1)
                           i =Instr(i+1,funzione,"]") - 1;
                        }
                     }
                    break;
                   }

     //CONTROLLO SE E' UNA TAN
                  case 'T':
                   {Mid(funzione_temp,funzione, i+2, 3);
                    if ((strcmp(funzione_temp, "an(")!=0) && (var_ok == 0))
                      return(0);
                    else
                     { if (strcmp(funzione_temp,"an(")==0)
                        i = i + 3;
                       else
                        { if (var_ok == 1)
                           i = Instr(i+1,funzione,"]") - 1;
                        }
                     }
                    break;
                   }

                 case 'L':
                 {    Mid(funzione_temp,funzione, i+2, 3);
                   if ((strcmp(funzione_temp, "og(")!=0)&&(var_ok == 0)&&(funzione_temp[0]!='n')&&(funzione_temp[1]!='('))
                      return(0);
                   else
                    { if (strcmp(funzione_temp, "og(")==0) //se è log incremento i di 3 altrimenti se ln di 2
                       i = i + 3;
                      else
                       {if ((funzione_temp[0]=='n')&&(funzione_temp[1]=='('))
                         i = i + 2;
                        else
                         {if (var_ok == 1)
                           i = Instr(i+1,funzione,"]") - 1;
                         }
                       }
                    }
                    break;
                   }
                 case 'E':
                   {Mid(funzione_temp,funzione, i+2, 3);
                   if ((strcmp(funzione_temp, "xp(")!=0) && (var_ok == 0))
                      return(0);
                    else
                     { if (strcmp(funzione_temp,"xp(")==0)
                        i = i + 3;
                       else
                        { if (var_ok == 1)
                           i = Instr(i+1,funzione,"]") - 1;
                        }
                     }
                    break;
                   }

                default: //SE E' PRESENTE LA VARIABILE ALLORA LA GESTISCO ALTRIMENTI E' ERRORE
                 {if (var_ok == 0)  //se trova un carattere non identificato allora è errore
                   return(0);
                  else
                   i = Instr(i+1,funzione,"]") - 1;
                 }
               }
              }else
                {if((funzione[i]!='(')&&(funzione[i]!=')')&&(funzione[i]<48)&&(funzione[i]>57))
                  return(0);// si tratta di caratteri non ammessi
                }
           }
      i++;
    }

 return(1);   //Se non trova errori restituisco 1

}
//**************************************************************************
/*
  * Nome funzione:     MettiPer
  * Parametri:         funzione    stringa che contiene l'espressione presa in
                                   input
  * Valori di ritorno: funzione -> stringa passata come parametro con
                                   l'aggiunta dei * dove necessario
  * Descrizione:       aggiunge alla stringa di parametro
                       il carattere * dove vi Š un prodotto e non Š stato
                       specificato dall'utente
                       es (f(x):=2x ->f(x):=2*x)

*/
//**************************************************************************

void TParserScomponi::MettiPer(char* funzione)
 {
   int indice=0;
   char* funzione_temp;
   char* funzione_temp2;
 while (indice < Len(funzione))
  {
  if(funzione[indice]=='[')
   {if (indice > 0)
     { if ((funzione[indice-1] != '*')&&(funzione[indice-1] != '^') && (funzione[indice-1]!= '+')&&(funzione[indice-1] !='-') && (funzione[indice-1]!= '/') && (funzione[indice-1]!=' ')&&(funzione[indice-1]!= '('))
        { funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+2));
          Mid(funzione_temp,funzione, 1, indice-1);
          Concatena(funzione_temp,"*");
          funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione)-indice+1));
          Mid(funzione_temp2,funzione, indice, Len(funzione) - indice );
          Concatena(funzione_temp,funzione_temp2);
          strcpy(funzione,funzione_temp);
          free(funzione_temp);
          free(funzione_temp2);
        }
     }
        indice = Instr(indice+1, funzione, "]");
    if ((Len(funzione) > indice + 1) && (funzione[indice]!='*')&&(funzione[indice]!='^')&&(funzione[indice]!='+')&&(funzione[indice]!='-')&&(funzione[indice]!='/')&&(funzione[indice]!=' ')&&(funzione[indice]!=')'))
     {  funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+2));
        Mid(funzione_temp,funzione, 1, indice);
        Concatena(funzione_temp,"*");
        funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione)-indice+2));
        Mid(funzione_temp2,funzione, indice + 1, Len(funzione) - indice+1 );
        Concatena(funzione_temp,funzione_temp2);
        strcpy(funzione,funzione_temp);
        free(funzione_temp);
        free(funzione_temp2);
     }
   }
   if (funzione[indice] == '(')
    {if (indice > 0)
     {if (funzione[indice-1] == ')')
      {
       funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+2));
       Mid(funzione_temp,funzione, 1, indice-1);
       Concatena(funzione_temp,"*");
       funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione)-indice+1));
       Mid(funzione_temp2,funzione, indice,Len(funzione) - indice );
       Concatena(funzione_temp,funzione_temp2);
       strcpy(funzione,funzione_temp);
       indice++;
       free(funzione_temp);
       free(funzione_temp2);
      }
     }
    }

  if (funzione[indice] == ')')
   {if ((Len(funzione) > indice + 1) && (funzione[indice+1] !='*') && (funzione[indice+1]!= '^')&&(funzione[indice+1]!= '+')&&(funzione[indice+1]!= '-')&&(funzione[indice+1]!= '/')&&(funzione[indice+1]!= ' ')&&(funzione[indice+1]!= ')'))
    {   funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+2));
        Mid(funzione_temp,funzione, 1, indice+1);
        Concatena(funzione_temp,"*");
        funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione)-indice+3));
        Mid(funzione_temp2,funzione, indice + 2, Len(funzione) - indice+2 );
        Concatena(funzione_temp,funzione_temp2);
        strcpy(funzione,funzione_temp);
        indice++;
        free(funzione_temp);
        free(funzione_temp2);
    }
   }
 //Controllo se Š un numero
  if ((funzione[indice]>=48)&&(funzione[indice]<=57))
   {if (indice > 0)
     {if ((funzione[indice-1]!='*') && (funzione[indice-1]!=',') && (funzione[indice-1]!='(') && (funzione[indice-1]!='^') && (funzione[indice-1]!='+') && (funzione[indice-1]!='-') && (funzione[indice-1]!='/') && (funzione[indice-1]!=' ')&&(funzione[indice-1]!='[') && ((funzione[indice-1]<48) || (funzione[indice-1]>57)))
      {
       funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+2));
       Mid(funzione_temp,funzione, 1, indice-1);
       Concatena(funzione_temp,"*");
       funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione)-indice+1));
       Mid(funzione_temp2,funzione, indice, Len(funzione) - indice );
       Concatena(funzione_temp,funzione_temp2);
       strcpy(funzione,funzione_temp);
       indice++;
       free(funzione_temp);
       free(funzione_temp2);
      }
     }
    if ((Len(funzione) > indice + 1)&&(funzione[indice+1] !='*')&&(funzione[indice+1] !=',')&&(funzione[indice+1] !=')')&&(funzione[indice+1] !='^')&&(funzione[indice+1] !='+')&&(funzione[indice+1] !=';')&&(funzione[indice+1] !='-')&&(funzione[indice+1] !='/')&&(funzione[indice+1] !=' ')&&((funzione[indice+1]<48) || (funzione[indice+1]>57)))
     {  funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+2));
        Mid(funzione_temp,funzione, 1, indice+1);
        Concatena(funzione_temp,"*");
        funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione)-indice+3));
        Mid(funzione_temp2,funzione, indice + 2, Len(funzione) - indice +2);
        Concatena(funzione_temp,funzione_temp2);
        strcpy(funzione,funzione_temp);
        indice++;
        free(funzione_temp);
        free(funzione_temp2);
     }
   }
     indice++;
}
}

//************************************************************************
/*
  * Nome funzione:     ParentesiElevati
  * Parametri:         funzione   stringa che contiene l'espressione presa in
                               input ed elaborata parzialmente precedentemente
  * Valori di ritorno: la stringa passata come parametro con l'aggiunta di
                       alcune parentesi
                       es (f(x):=3x^2 ->f(x):=3(x^2))
  * Descrizione:       questa funzione ha il compito di inserire nella
                       stringa parentesi  per stabilire, successivamente,
                       la priorit…,
                       rispetto agli altri operatori,dell'elevamento a potenza

*/
//**************************************************************************


 void TParserScomponi::ParentesiElevati(char* funzione)
 {
   int posizione_elevato;
   int numero_parentesi;
   int posizione_scorr;
   int flag;
   char* funzione_temp;
   char* funzione_temp2;
     posizione_elevato=Instr(1,funzione,"^")-1;

     while (posizione_elevato > 0)
      {  posizione_scorr = posizione_elevato-1;
       if (funzione[posizione_scorr]!= ')')
        {while ((posizione_scorr > 0)&&(funzione[posizione_scorr]!= '^')&&(funzione[posizione_scorr]!= '*')&&(funzione[posizione_scorr]!= '/')&&(funzione[posizione_scorr]!= '+')&&(funzione[posizione_scorr]!= '-')&&(funzione[posizione_scorr]!= '('))
         {  posizione_scorr--;
         }
         if (posizione_scorr > 0)
            posizione_scorr++;
        }
       else
        {   numero_parentesi = 1;
         while (numero_parentesi > 0)
          { posizione_scorr--;
           if (funzione[posizione_scorr] == ')')
            numero_parentesi++;
           else
            {if (funzione[posizione_scorr] == '(')
              numero_parentesi--;
            }
          }
        }
           funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+5));
           Mid(funzione_temp,funzione, 1, posizione_scorr );
           Concatena(funzione_temp,"(");
           funzione_temp2=(char*)malloc(sizeof(char)*(posizione_elevato - posizione_scorr + 2));
           Mid(funzione_temp2,funzione, posizione_scorr+1, posizione_elevato - posizione_scorr + 1);
           Concatena(funzione_temp, funzione_temp2);
           free(funzione_temp2);
           funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione) - posizione_elevato));
           Mid(funzione_temp2,funzione, posizione_elevato+2 , Len(funzione) - posizione_elevato);
           Concatena(funzione_temp,funzione_temp2);
           free(funzione_temp2);
           strcpy(funzione,funzione_temp);
           free(funzione_temp);
           posizione_elevato = Instr(posizione_elevato + 1, funzione, "^")-1;
           posizione_scorr = posizione_elevato + 1;
         if (funzione[posizione_scorr]!='(')
          { flag = 1;
           while ((flag == 1)&&(posizione_scorr < Len(funzione)-1)&&(funzione[posizione_scorr]!='*')&&(funzione[posizione_scorr]!='^')&&(funzione[posizione_scorr]!='/'))
           { if ((posizione_scorr > posizione_elevato + 1)&&((funzione[posizione_scorr]=='+')||(funzione[posizione_scorr]=='-')))
              flag = 0;
             else
              posizione_scorr++;
           }
          if (posizione_scorr < Len(funzione)-1)
          posizione_scorr--;

    }else
     {     numero_parentesi = 1;
        while (numero_parentesi > 0)
         {  posizione_scorr++;
          if (funzione[posizione_scorr] == ')')
           numero_parentesi--;
          else
          {if (funzione[posizione_scorr] == '(')
           numero_parentesi++;
          }
         }

    }
         funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+5));
         Mid(funzione_temp,funzione,1,posizione_scorr+1);
         Concatena(funzione_temp,")");
         funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione)-posizione_scorr));
         Mid(funzione_temp2,funzione,posizione_scorr+2,Len(funzione)-posizione_scorr-1);
         Concatena(funzione_temp,funzione_temp2);
         strcpy(funzione,funzione_temp);
         posizione_elevato = Instr(posizione_elevato + 2, funzione, "^")-1;
         free(funzione_temp);
         free(funzione_temp2);
 }
}

//************************************************************************
/*
  * Nome funzione:     GestioneMeno
  * Parametri:         funzione   stringa che contiene l'espressione presa in
                                  input
  * Valori di ritorno: la stringa presa come parametro con qualche piccolo
                       ritocco dove necessario

  * Descrizione: aggiunge uno 0 e toglie i + dove non sono necessari per
                 facilitarne l'interpretazione successiva
                 es f(x):=x*(+2*x)->x(2*x)
                    f(x):=-x^2->0-x^2
*/
//**************************************************************************

void TParserScomponi::GestioneMeno(char* funzione)
{ int posizione_parentesi;
  char* funzione_temp;
  char* funzione_temp2;
   posizione_parentesi = Instr(1, funzione, "(")-1;

 while (posizione_parentesi > -1)
 { if (funzione[posizione_parentesi+1] == '-')
   {  funzione_temp=(char*)malloc(sizeof(char)*(Len(funzione)+2));
      Mid(funzione_temp,funzione, 1, posizione_parentesi+1);
      Concatena(funzione_temp,"0");
      funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione) - posizione_parentesi));
      Mid(funzione_temp2,funzione, posizione_parentesi + 2, Len(funzione) - posizione_parentesi);
      Concatena(funzione_temp,funzione_temp2);
      strcpy(funzione,funzione_temp);
      free(funzione_temp);
      free(funzione_temp2);
    }
   else
   { if (funzione[posizione_parentesi+1] == '+')
     { funzione_temp=(char*)malloc(sizeof(char)*Len(funzione));
       Mid(funzione_temp,funzione, 1, posizione_parentesi+1);
       funzione_temp2=(char*)malloc(sizeof(char)*(Len(funzione) - 1 - posizione_parentesi));
       Mid(funzione_temp2,funzione, posizione_parentesi + 3, Len(funzione) - 1 - posizione_parentesi);
       Concatena(funzione_temp,funzione_temp2);
       strcpy(funzione,funzione_temp);
       free(funzione_temp);
       free(funzione_temp2);

     }
   }
     posizione_parentesi = Instr(posizione_parentesi + 2, funzione, "(")-1;
 }
}

//************************************************************************
/*
  * Nome funzione:     Gestione Variabili
  * Parametri:         funzione    stringa che contiene l'espressione presa in
                                   input
                       n_variabili contiene il numero di variabili in funzione

  * Valori di ritorno:  nessuno

  * Descrizione:       sub che qualora rileva una variabile nella funzione,la sostituisca con
                       l'espressione  [nome variabile, indice], indice ha la funzione di numerare
                       ciascuna variabile
                       es f(a,b):=a^2+b^2+a  ->     [a,1]^2+[b,2]^2+[a,1]
*/

void TParserScomponi::GestioneVariabili(char* funzione,int n_variabili)
{
  variab* variabili_iniziali;
  int i,flag;
  variab temp_variabile;
  char variabile[20];
  int posizione_scorr;
  char funzione_temp[2000],funzione_temp2[2000],numstringa[20];

 if (n_variabili > 0)
   {
      variabili_iniziali=(variab*)malloc(sizeof(variab)*n_variabili);
  //Devo memorizzarmi una copia dell'ordine iniziale delle variabili
    for(i=0;i<n_variabili;i++)
    {
     (variabili_iniziali+i)->variabile=(char*)malloc(sizeof(char)*(Len((variabili+i)->variabile)));
     strcpy((variabili_iniziali+i)->variabile,(variabili+i)->variabile);
    }
    do               //Ordino le variabili decrescentemente
     { flag=0;
       i=0;
      while(i<n_variabili-1)
       {if(Len((variabili+i)->variabile)<Len((variabili+i+1)->variabile))
         {temp_variabile=*(variabili+i);
          *(variabili+i)=*(variabili+i+1);
          *(variabili+i+1)=temp_variabile;
          flag=1;
         }
          i++;
       }
     }while(flag==1);

     for (i = 1;i<=n_variabili;i++)
      {   strcpy(variabile,(variabili+i-1)->variabile);
          posizione_scorr = 0;
        while (posizione_scorr <= Len(funzione)) //SOSTIUISCO LE VARIABILI NELLA FUNZIONE CON [...,...]
        { posizione_scorr = posizione_scorr + 1;
 //Utilizzo funzione_temp per semplificare il successivo confronto
          Mid(funzione_temp,funzione, posizione_scorr, 3);
         if (funzione[posizione_scorr-1] == '[')
           posizione_scorr=Instr(posizione_scorr,funzione,"]")+1;
           Mid(funzione_temp2,funzione, posizione_scorr, Len(variabile));
         if ((strcmp(funzione_temp2,variabile)==0)&&(strcmp(funzione_temp,"Sin")!=0) && (strcmp(funzione_temp,"Cos")!=0) && (strcmp(funzione_temp,"Exp")!=0) && (strcmp(funzione_temp,"Log")!=0) && (strcmp(funzione_temp,"Tan")!=0) &&((funzione[posizione_scorr-1]!='L')||(funzione[posizione_scorr-1]!='n')))
          {
           Mid(funzione_temp,funzione, 1, posizione_scorr - 1) ;
           Concatena(funzione_temp,"[");
           Concatena(funzione_temp,variabile);
           Concatena(funzione_temp,"]");
           Mid(funzione_temp2,funzione, posizione_scorr + Len(variabile), Len(funzione) - posizione_scorr - Len(variabile)+1 );
           strcpy(funzione,funzione_temp2);
           Concatena(funzione_temp,funzione);
           strcpy(funzione,funzione_temp);
           posizione_scorr = Instr(posizione_scorr, funzione, "]");
          }else
          { Mid(funzione_temp,funzione, posizione_scorr, 2);
           if (strcmp(funzione_temp,"Ln")==0)
              posizione_scorr = posizione_scorr + 1;
             Mid(funzione_temp,funzione, posizione_scorr, 3);
            if ((strcmp(funzione_temp,"Abs")==0) ||(strcmp(funzione_temp,"Sin")==0) || (strcmp(funzione_temp,"Cos")==0) || (strcmp(funzione_temp,"Exp")==0) || (strcmp(funzione_temp,"Log")==0) || (strcmp(funzione_temp,"Tan")==0))
              posizione_scorr = posizione_scorr + 2;

         }
       }
     }


 //Dealloco la struttura temporanea
     for(i=0;i<n_variabili;i++)
     {
      free((variabili+i)->variabile);
     }
      free(variabili);
      variabili=variabili_iniziali;


    for(i=0;i<n_variabili;i++)
    {
      posizione_scorr=Instr(1,funzione,"[");
     while((posizione_scorr<Len(funzione))&&(posizione_scorr>0))
      {  Mid(funzione_temp,funzione,posizione_scorr+1,Instr(posizione_scorr,funzione,"]")-1-posizione_scorr);
       if(strcmp(funzione_temp,(variabili+i)->variabile)==0)
        { Mid(funzione_temp,funzione,1,posizione_scorr-1);
          Concatena(funzione_temp,"[");
          sprintf(numstringa,"%d",i);
      //NumStr(i,numstringa);
          Concatena(funzione_temp,numstringa);
          Concatena(funzione_temp,";");
          Concatena(funzione_temp,(variabili+i)->variabile);
          Mid(funzione_temp2,funzione,Instr(posizione_scorr,funzione,"]"),Len(funzione)-Instr(posizione_scorr,funzione,"]")+2);
          Concatena(funzione_temp,funzione_temp2);
          strcpy(funzione,funzione_temp);
        }
         posizione_scorr=Instr(posizione_scorr+1,funzione,"[");

      }
    }
   }

   for(i=0;i<n_variabili;i++)
     {
      free((variabili+i)->variabile);
     }
      free(variabili);

   //'----------------------FINE GESTIONE DELLE VARIBILI---------------------------------------

}

rif* TParserScomponi::Traduci_funzione(char* funzione)
{
 int parentesi=0,posizione_scorr,posizione_meno,posizione_piu,indice;
 int errore;
 int xpos,ypos=0,posizione_parentapri,assegnato,posizione_parentchiudi,cont,var_ok;
 char *funzione_iniziale,variabile[30],funzione_temp[600],funzione_temp2[600];
 int codice_lettere;
 int temp=0;
 int esiste;
 char char_temp[2];
 int cont_operatori=0;
 int n_variabili=0;
 int numero_scomposizioni=0;
 int posizione_variabile;
 char strassegnazione[250];



    char_temp[1]='\0';
    strcpy(strassegnazione,"");
    assegnato=Gestione_assegnazione(funzione,&errore,&n_variabili);
 if(assegnato==1) //Se vi è stata una corretta assegnazione
  {
    Mid(strassegnazione,funzione,1,Instr(1,funzione,":=")+1);
    Mid(funzione_temp,funzione,Instr(1,funzione,":=")+2,Len(funzione)-Instr(1,funzione,":=")-1);
    strcpy(funzione,funzione_temp);
  }
    Lcase(funzione);//Funzione che riscrive appropriatamente parti della funzione
    GestioneVariabili(funzione, n_variabili);

 if((Controllo_sintassi(funzione)==1)&&(errore==1))
  {
    MettiPer(funzione);
    funzione_iniziale=(char*)malloc(sizeof(char)*(Len(funzione)+1));
    strcpy(funzione_iniziale,funzione);
    ParentesiElevati(funzione);
//inizializzo il codice ascii delle lettere che utilizzero come riferimenti
    codice_lettere = 96;
//aggiungo delle parentesi alla funzione iniziale
    strcpy(funzione_temp,"(");
    Concatena(funzione_temp,funzione);
    Concatena(funzione_temp,")");
    strcpy(funzione,funzione_temp);
    GestioneMeno(funzione);
    posizione_scorr = 1;
    posizione_parentapri=0;
    posizione_parentapri = Instr(posizione_parentapri+1 , funzione, "(");

//Conto il numero di parentesi (
 while(posizione_parentapri>0)
  { parentesi++;
    posizione_parentapri = Instr(posizione_parentapri+1 , funzione, "(");
  }

//alloco la struttura dati che conterr… la funzione scomposta
   vettore_riferimenti=(riferimenti*)malloc(sizeof(riferimenti)*parentesi);
   parentesi=0;

//cerco la prima ( nella funzione
   posizione_parentapri = Instr(posizione_scorr , funzione, "(");
//cerco ) nella funzione
   posizione_parentchiudi = Instr(posizione_scorr, funzione, ")");

 while (posizione_parentapri > 0) //se esistono nella funzione delle parentesi allora..
  {     //cerco sempre la coppia di parentesi (..) piu interna
    while ((posizione_parentapri < posizione_parentchiudi)&&(posizione_parentapri > 0))
     {temp = posizione_parentapri;
      posizione_scorr = posizione_parentapri + 1;
      posizione_parentapri = Instr(posizione_scorr, funzione, "(");
      parentesi++;
     }
     posizione_parentapri = temp; //se tra le 2 parentesi c'e solo un carattere o un numero allora non è il caso di semplificare
     esiste = 0;
     cont = 0;
//cerco nel vettore riferimenti per evitare ridondanze
    while ((cont < ypos)&&(esiste == 0))
     {    //cerco nel vettore riferimenti per evitare ridondanze
        Mid(funzione_temp,funzione, posizione_parentapri + 1, posizione_parentchiudi - posizione_parentapri - 1);
       if (strcmp(funzione_temp,(vettore_riferimenti+cont)->descrizione)==0)
        esiste = 1;

        cont++;
      }
        var_ok = 0;
//Se tra due parentesi c'e solo una variabile Š inutile scomporre
    if((funzione[posizione_parentapri]=='[')&&((Instr(posizione_parentapri+2,funzione,"[")==0)||(Instr(posizione_parentapri+2,funzione,"[")>posizione_parentchiudi))&&(funzione[posizione_parentchiudi-2]==']'))
        var_ok=1;

        Mid(funzione_temp,funzione, posizione_parentapri + 1, posizione_parentchiudi - posizione_parentapri - 1);
    if (((parentesi == 1)||((Isnumeric(funzione_temp)==0))&&(Len(funzione_temp) > 1))&&(var_ok==0) )
     { if(esiste==0)
        { codice_lettere++; //riscrivo la funzione inserirendo la lettera di riferimento invece della parentesi estratta
//inserisco in un vettore un riferimento al contenuto della parentesi
          (vettore_riferimenti+ypos)->descrizione=(char*)malloc(sizeof(char)*(posizione_parentchiudi - posizione_parentapri));
          Mid((vettore_riferimenti+ypos)->descrizione,funzione, posizione_parentapri + 1, posizione_parentchiudi - posizione_parentapri - 1);

          char_temp[0]=codice_lettere;
          Mid(funzione_temp,funzione, 1, posizione_parentapri - 1);
          Concatena(funzione_temp,char_temp);
          Mid(funzione_temp2,funzione, posizione_parentchiudi + 1, Len(funzione) - posizione_parentchiudi);
          Concatena(funzione_temp,funzione_temp2);
          strcpy(funzione,funzione_temp);
           ypos++;

        }
       else
        { char_temp[0]=95 + cont+1;
          Mid(funzione_temp,funzione, 1, posizione_parentapri - 1);
          Concatena(funzione_temp,char_temp);
          Mid(funzione_temp2,funzione, posizione_parentchiudi + 1, Len(funzione) - posizione_parentchiudi);
          Concatena(funzione_temp,funzione_temp2);
          strcpy(funzione,funzione_temp);
        }
     }
    else

     { Mid(funzione_temp,funzione, 1, posizione_parentapri - 1);
       Mid(funzione_temp2,funzione, posizione_parentapri + 1, posizione_parentchiudi - posizione_parentapri - 1);
       Concatena(funzione_temp, funzione_temp2);
       Mid(funzione_temp2,funzione, posizione_parentchiudi + 1, Len(funzione) - posizione_parentchiudi);
       Concatena(funzione_temp,funzione_temp2);
       strcpy(funzione,funzione_temp);
     }

    posizione_scorr = 1;
    posizione_parentapri = Instr(posizione_scorr, funzione, "(");
    posizione_parentchiudi = Instr(posizione_scorr, funzione, ")");
  }
    numero_scomposizioni = ypos;
    ypos = 0;
   if(numero_scomposizioni==0) //Ci deve essere almeno una scomposizione
    { numero_scomposizioni=1;
      vettore_riferimenti->descrizione=funzione;
    }


    // ------------SCOMPOSIZIONE DELLE SOMME O E MEMORIZZAZIONE NELLA MATRICE_SCOMPOSIZIONE------------


    vettore_riferimenti->n_variabili=n_variabili;
    vettore_riferimenti->numero_scomposizioni=numero_scomposizioni;

  for (indice = 0;indice<numero_scomposizioni;indice++)
   { xpos = 0;
     posizione_scorr = 0;
     strcpy(funzione_temp,(vettore_riferimenti+indice)->descrizione);
     posizione_meno = Instr(posizione_scorr+1,funzione_temp, "-");
     posizione_piu = Instr(posizione_scorr+1,funzione_temp, "+");
  //Conto gli operatori + e - per la successiva allocazione
    while((posizione_meno>0)||(posizione_piu>0))
     {
     if((posizione_meno>0)&&(posizione_piu>0))
      cont_operatori=cont_operatori+2;
     else
      cont_operatori++;

      posizione_meno = Instr(posizione_meno+2,funzione_temp, "-");
      posizione_piu = Instr(posizione_piu+2,funzione_temp, "+");
     }
     posizione_meno = Instr(posizione_scorr+1,funzione_temp, "-");
     posizione_piu = Instr(posizione_scorr+1,funzione_temp, "+");
    if(posizione_meno>0) posizione_meno--;
    if(posizione_piu>0) posizione_piu--;

     (vettore_riferimenti+indice)->scomposizioni=(scompos*)malloc(sizeof(scompos)*(2*cont_operatori+1));

   while (((posizione_meno > 0)&&(posizione_meno < 250))||((posizione_piu > 0)&&(posizione_piu < 250)))
    { if (posizione_meno == 0)  posizione_meno = 250;
      if (posizione_piu == 0)  posizione_piu = 250;

     if (posizione_meno < posizione_piu)
     { if (posizione_meno > 0)
       { if ((funzione_temp[posizione_meno - 1] == '^')||(funzione_temp[posizione_meno - 1] == '*')||(funzione_temp[posizione_meno - 1] == '/'))
          posizione_meno = Instr(posizione_meno + 1,funzione_temp, "-");
       }
     }

     if (posizione_piu < posizione_meno)
      {if (posizione_piu >0)
       {if ((funzione_temp[posizione_piu - 1] == '^')||(funzione_temp[posizione_piu - 1] == '*')||(funzione_temp[posizione_piu - 1] == '/'))
         posizione_piu = Instr(posizione_piu + 1,funzione_temp, "+");
       }
      }

     if (posizione_meno == 0) posizione_meno = 250;
     if (posizione_piu == 0)  posizione_piu = 250;

     if ((posizione_meno < 250)||(posizione_piu < 250))
      {if (posizione_meno < posizione_piu)
        {Mid(funzione_temp2,funzione_temp, posizione_scorr+1, posizione_meno - posizione_scorr);
         ScomponiProdotti(funzione_temp2,(((vettore_riferimenti+indice)->scomposizioni)+xpos),posizione_meno - posizione_scorr);
         xpos++;
         (((vettore_riferimenti+indice)->scomposizioni)+xpos)->scomposizione=(char**)malloc(sizeof(char*));
         *((((vettore_riferimenti+indice)->scomposizioni)+xpos)->scomposizione)=(char*)malloc(sizeof(char));
         *((((vettore_riferimenti+indice)->scomposizioni)+xpos)->scomposizione)="-";

          posizione_scorr = posizione_meno + 1;
        }
        else
        {
         Mid(funzione_temp2,funzione_temp, posizione_scorr+1, posizione_piu - posizione_scorr);
         ScomponiProdotti(funzione_temp2,(((vettore_riferimenti+indice)->scomposizioni)+xpos),posizione_piu - posizione_scorr);

         xpos++;
        (((vettore_riferimenti+indice)->scomposizioni)+xpos)->scomposizione=(char**)malloc(sizeof(char*));
         *((((vettore_riferimenti+indice)->scomposizioni)+xpos)->scomposizione)=(char*)malloc(sizeof(char));
         *((((vettore_riferimenti+indice)->scomposizioni)+xpos)->scomposizione)="+";
         posizione_scorr = posizione_piu + 1;
        }
         (((vettore_riferimenti+indice)->scomposizioni)+xpos)->n_colonne=1;
         xpos++;
         posizione_meno = Instr(posizione_scorr+1,funzione_temp, "-");
         posizione_piu = Instr(posizione_scorr+1,funzione_temp, "+");
         if(posizione_meno>0) posizione_meno--;
         if(posizione_piu>0) posizione_piu--;

      }

   }

     Mid(funzione_temp2,funzione_temp, posizione_scorr+1, Len(funzione_temp) - posizione_scorr );
     ScomponiProdotti(funzione_temp2,(((vettore_riferimenti+indice)->scomposizioni)+xpos),  Len(funzione_temp) - posizione_scorr+1);
    (vettore_riferimenti+ypos)->lunghezza_scomp = xpos + 1;

    ypos++;
 }
 // RIPRISTINO I NOMI INIZIALI DELLE VARIABILI

    posizione_variabile = Instr(1, funzione_iniziale, "[");
   while (posizione_variabile > 0)
    {Mid(variabile,funzione_iniziale, Instr(posizione_variabile,funzione_iniziale,";")+1, Instr(posizione_variabile, funzione_iniziale, "]") - Instr(posizione_variabile,funzione_iniziale,";") - 1);
     Mid(funzione_temp,funzione_iniziale, 1, posizione_variabile - 1);
     Concatena(funzione_temp,variabile);
     Mid(funzione_temp2,funzione_iniziale, Instr(posizione_variabile, funzione_iniziale, "]") + 1, Len(funzione_iniziale) - Instr(posizione_variabile, funzione_iniziale, "]"));
     Concatena(funzione_temp,funzione_temp2);
     strcpy(funzione_iniziale,funzione_temp);
     posizione_variabile = Instr(1, funzione_iniziale, "[");
    }
    strcpy(funzione,funzione_iniziale);
   //queste operazioni sono legate al fatto che occorre restituire anche la stringa di connessione
    Concatena(strassegnazione,funzione);
    strcpy(funzione,strassegnazione);
    free(funzione_iniziale);


    return(vettore_riferimenti);

 }
  else
   strcpy(funzione,"err");
   return(0);
}

void TParserScomponi::ScomponiProdotti(char* spezzone,scomp* puntascomp,int lunghezzaspezzone)
{   int i,numerooperatori=0,posizionepartenza=0,indice=0;

    for(i=0;i<lunghezzaspezzone;i++)
    {
      if((spezzone[i]=='*')||(spezzone[i]=='/')||( spezzone[i]=='^'))
       numerooperatori++;
    }
     (*puntascomp).n_colonne=numerooperatori*2+1;
     (*puntascomp).scomposizione=(char**)malloc(sizeof(char*)*((*puntascomp).n_colonne));
 for(i=0;i<=lunghezzaspezzone;i++)
    {
      if((spezzone[i]=='*')||(spezzone[i]=='/')||( spezzone[i]=='^')||(i==lunghezzaspezzone))
       {
          *((*puntascomp).scomposizione+indice)=(char*)malloc(sizeof(char)*(i-posizionepartenza+1));
          Mid(*((*puntascomp).scomposizione+indice),spezzone,posizionepartenza+1,i-posizionepartenza);
        if(i!=lunghezzaspezzone)
         { indice++;
           *((*puntascomp).scomposizione+indice)=(char*)malloc(sizeof(char));
           **((*puntascomp).scomposizione+indice)=spezzone[i];
           indice++;
           posizionepartenza=i+1;
         }
       }

    }

}