//g++ Ydf1.cc -Wall -o Ydf1

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#define BUFSIZE           2048
#define LG_MAX_NAME         24
#define NB_MAX_VARIAB    10000
#define LG_MAX_BIGVAR      128
#define NB_MAX_EXPRESYM  10000
#define NB_MAX_DIFFVAR   10000
//#define NB_MAX_CPLX     1000

/*=============================================================================*/
struct st_diff {
	char		vardiff[LG_MAX_NAME*2 + 1];
	int 		deblockportee;
};

/*=============================================================================*/
short   trace=0;
FILE    *fpmodul, *fpginac;
//char	  modul_file_name[LG_MAX_NAME+1];
int     i, j=0, k;
char	  buffer[BUFSIZE+1];
char    delim[] =" \t(),\n";
//char	  *pstr1, *pstr3, *pstrw;
//char	  *pstr2=NULL;
short   Phase=0;
int     NbIn, NbOut;
int     indicYS=0;
int     indic=0;
char	  instruct[BUFSIZE+1];
short   indicBLOCK=0;
short   indicCROUV=0;
short   indicTAB=0;
char    TabVar[NB_MAX_VARIAB][LG_MAX_BIGVAR+1];
int     NbVar=0;
short   indicDECLAR=0;
short   indicAFFECT=0;
short   prodlevel=0;
char    Ysubstit[LG_MAX_NAME+1];
int     iexp;

char    TabExpreSym[NB_MAX_EXPRESYM][LG_MAX_NAME + 1];
short   TabFlagIn[NB_MAX_EXPRESYM];
int     NbExpreSym = 0;
//char	  affectsv[BUFSIZE+1];
struct  st_diff TabDiff[NB_MAX_DIFFVAR];
int     NbDiff = 0;

int     CurBlockLev = 0; //semaphore de decompte des accolades pour gerer le niveau d'imbrication des block

char    ModulName[LG_MAX_NAME+1];
//int     lenModulName;

char    TabDejaDiff[NB_MAX_DIFFVAR][LG_MAX_NAME+1]; //!!! tableau en global a usage local : initialement, et
int     NbDejaDiff;                                 //    localement, mettre NbDejaDiff a ZERO !

short   flagCPLX=0;
int     NbInCplx=0;
//char    TabCplx[NB_MAX_CPLX][LG_MAX_NAME + 1];
//int     NbCplx=0;

//principaux mots du langage C/C++ (liste non exhaustive ... )
#define NB_CWORD  109
char    TabCword [NB_CWORD][LG_MAX_NAME] =
{       "abs",      "acos",     "asin",     "atan",    "atan2",    "atoi",
        "atof",     "atol",     "break",    "case",    "char",     "close",  "complex",
        "const",    "continue", "cos",      "cosh",    "default",  "delete",
        "div",      "do",       "double",   "enum",    "else",     "exp",
        "exit",     "extern",   "fabs",     "float",   "fclose"    "feof",
        "fgetc",    "fgets",    "fopen",    "for",     "fprintf",  "fputc",
        "fputs",    "free",     "getc",     "getchar", "getenv",   "gets",
        "goto",     "if",       "int",      "isalnum", "isdigit",  "islower",
        "isupper",  "log",      "log10",    "long",    "memchr",   "memcmp",
        "memcpy",   "memove",   "new",      "NULL",    "open",     "pow",
        "putenv",   "puts",     "rand",     "read",    "return",   "scanf",
        "setenv",   "sprintf",  "short",    "sin",     "sinh",     "sizeof",
        "sqrt",     "srand",    "sscanf",   "static",  "stdin",    "stdout",
        "strcat",   "strchr",   "strcmp",   "strcpy",  "strlen",   "strncat",
        "strncmp",  "strncpy",  "strpbrk",  "strrchr", "strspn",   "strstr",
        "strtok",   "strtol",   "struct",   "switch",  "tan",      "tanh",
        "tolower",  "toupper",  "typedef",  "union",   "unsigned", "void",
        "volatile", "vfprintf", "vsprintf", "while",   "write",    "YREAL",
};

/*=============================================================================*/

//*---------------------------------------------------------------------------*/
int c_word(char *word)
{   int	wi;
    for (wi=0; wi<NB_CWORD; ++wi)
    {	  if (!strcmp(word, TabCword[wi]))
	         return (1);
    }
    return(0);
}
//*---------------------------------------------------------------------------*/
char *str_affect(char *str)
{    char *pstr;

     pstr = strstr(str, "+=");  if (pstr != NULL) return pstr;
     pstr = strstr(str, "-=");  if (pstr != NULL) return pstr;
     pstr = strstr(str, "*=");  if (pstr != NULL) return pstr;
     pstr = strstr(str, "/=");  if (pstr != NULL) return pstr;

     pstr = strstr(str, "==");
     if (pstr != NULL)  return (str_affect(pstr+2));
     pstr = strstr(str, ">=");
     if (pstr != NULL)  return (str_affect(pstr+2));
     pstr = strstr(str, "<=");
     if (pstr != NULL)  return (str_affect(pstr+2));
     pstr = strstr(str, "!=");
     if (pstr != NULL)  return (str_affect(pstr+2));
     //autres cas non traited plm : <<=, >>=, &=, ^=, |=

     //et enfin le cas d'une simple affectation
     pstr = strstr(str, "=");  if (pstr != NULL) return pstr;

     return(NULL);
}
/*---------------------------------------------------------------------------*/
void str_lesschr(char *str, char car)
{ int lg, i,j;
  lg = strlen(str);
  i=j=0;
  for (i=0; i<lg; ++i)
  {   if (str[i]==car) continue;
      str[j]=str[i];
      ++j;
  }
  str[j]='\0';
}
/*---------------------------------------------------------------------------*/
int str_qalphanum(char *str)
{   int lgstr = strlen(str);
    int i=0;
    short alphok=0;
    while (i<lgstr)
    {  if ( !isalnum(str[i]) && str[i]!='_') return(0);
       if ( isalpha(str[i]) || str[i]=='_') alphok = 1;
       ++i;
    }
    if (alphok) return(1);
    return(0);
}
/*---------------------------------------------------------------------------*/
int str_qdigit(char *str)
{   int lgstr = strlen(str);
    int i;
    for (i=0; i<lgstr; ++i)
    {  if (!isdigit(str[i])) return(0);
    }
    return(1);
}
/*---------------------------------------------------------------------------*/
char *str_tok(char *str, char *delim, char *svdelim, char *pmax)
{    char *p1, *p2;

     if (str>=pmax) return (NULL);

     p1 = str;
     //se positionner sur le 1er caratere non delimiteur
     while (p1[0]!='\0' && strchr(delim, p1[0])!=NULL) ++p1;
     //avancer tant qu'on ne retombe pas sur un caratere delimiteur
     p2=p1;
     while (p2[0]!='\0' && strchr(delim, p2[0])==NULL) ++p2;
     //on informe du delimiteur trouved avant de l'ecraser par '\0'
     *svdelim=p2[0];
     p2[0]='\0';
     return(p1);
}

/*---------------------------------------------------------------------------*/
void BackwardOut(char *instruct)
{    char   *pstr1, *pstr2;
     char    bufwrk[BUFSIZE+1];

     if (trace) printf("\n/*BO:%s:*/\n", instruct);

     strcpy(bufwrk, instruct);
     pstr1 = bufwrk;
		 fprintf(fpginac, "  cout ");
     while (1)
     {  pstr2 = strpbrk(pstr1, "\n\"");
        if (pstr2!=NULL)
        {
           if (pstr2[0]=='\n')
           {  pstr2[0]='\0';
              fprintf(fpginac," <<\"%s\" <<endl ",pstr1);
              pstr1=pstr2+1;
           }
           else
           {  pstr2[0]='\0';
              fprintf(fpginac,"<<\"%s\\\"\" ", pstr1);
              pstr1=pstr2+1;
           }
        }
        else
        { fprintf(fpginac," <<\"%s\"",pstr1);
          break;
        }
     }
     fprintf(fpginac, " ;\n");
}

/*---------------------------------------------------------------------------*/
int add_var(char *strvar)
{
    if (NbVar>=NB_MAX_VARIAB)
    {  printf("Ydf1: too much variables in that modul (%s)\n", ModulName);
       exit(-9);
    }
    strcpy(TabVar[NbVar], strvar);
    ++NbVar;
    return(NbVar-1);
}

/*---------------------------------------------------------------------------*/
short is_yadvar(char *str)
{   char bufstr[7];
    strncpy(bufstr, str, 6);  //strcpy(bufstr, str);
    bufstr[6]='\0';
    return (!strcmp(bufstr, "Yadvar"));
}

/*---------------------------------------------------------------------------*/
int exist_expresym(char *expresym)
{
    int	wi;
    for (wi=0; wi<NbExpreSym; ++wi)
    {	if (!strcmp(expresym, TabExpreSym[wi]))
	   return (1);
    }
    return(0);
}

/*---------------------------------------------------------------------------*/
int id_diff(char *diff)
{
    int	wi;
    for (wi=0; wi<NbDiff; ++wi)
    {	if (!strcmp(diff, TabDiff[wi].vardiff))
	       return (wi);
    }
    return(-1);
}
/*---------------------------------------------------------------------------*/
void decrem_diff_blocklev()
{
    int	wi;
    for (wi=0; wi<NbDiff; ++wi)
    {	  if (TabDiff[wi].deblockportee  == CurBlockLev)
           TabDiff[wi].deblockportee = 0;
    }
    --CurBlockLev;
}

/*---------------------------------------------------------------------------*/
/*int is_input(char *str)
{
    int	wi;
    for (wi=0; wi<NbIn; ++wi)
    {	  if (!strcmp(str, TabExpreSym[wi]))
	         return (1);
    }
    return(0);
}
int is_input(char *str)
{
    int	wi, nballin;
		nballin = NbIn+NbInCplx;
    for (wi=0; wi<nballin; ++wi)
    {	  if (!strcmp(str, TabExpreSym[wi]))
	         return (1);
    }
    return(0);
}
*/
int id_input(char *input)
{
    int	wi, nballin;
		nballin = NbIn+NbInCplx;
    for (wi=0; wi<nballin; ++wi)
    {	if (!strcmp(input, TabExpreSym[wi]))
	       return (wi);
    }
    return(-1);
}

/*---------------------------------------------------------------------------*/
int id_YSi(char *tok)
{   int num;
    if (tok[0]!='Y' || tok[1]!='S') return(0);
		if (tok[2]=='0') return(0);
		if (!str_qdigit(&tok[2])) return (0);
		num = atoi(&tok[2]);
		if (num<=NbOut) return(num);
    return(0);
}

/*---------------------------------------------------------------------------*/
void transfo_affect(char *instruct, char *pstr2)
{//   ...VAR {+,-,*,/}= EXPR ;   a tranformer en :--->    VAR = VAR {+,-,*,/} ( EXPR ) ;
 //   ( avec pstr2 qui pointera sur le = et non plus le {+,-,*,/}= )

     char    bufwrk[BUFSIZE+1];
     char    *p3;

     //printf("befor|%s|%c|\n", instruct, pstr2[0]);

		 memset(bufwrk, '\0', BUFSIZE+1);
		 bufwrk[0]=pstr2[-1];
		 pstr2[-1] = '\0'; //on termine la variable affectee par un '\0'

		 //il faut retrouver la variable affectee (ie se positionner dessus)
		 p3 = pstr2-2;
     while ((p3[0]==' ' || p3[0]=='\t') && p3>instruct) --p3; //on remonte les espaces et \t
     while (p3[0]!=' ' && p3[0]!='\t' && p3>instruct) --p3; //on remonte les autres caractères
		 if (p3<instruct) p3=instruct; //en faisant attention de rester sur l'instruction

		 //
		 strcat(bufwrk, "= ");  								//'= '
		 strcat(bufwrk, p3);										//VAR
		 strcat(bufwrk, " ");										//' '
		 bufwrk[strlen(bufwrk)] = pstr2[0];		  //{'+','-','*','/'}
		 strcat(bufwrk, " (");									//' ('
		 strcat(bufwrk, pstr2+2);								//EXPR ;
		 bufwrk[strlen(bufwrk)-1] = '\0';   		//pour enlever le ';' de fin
		 strcat(bufwrk, " ) ;");								//et le remplacer par ' ) ;"

		 //
		 strcat(instruct, bufwrk);

     //printf("after|%s|%c|\n", instruct, pstr2[0]);
}

/*---------------------------------------------------------------------------*/
void substitut_by_symbol(char *str)
{    char    *pstr1, *pmax;
     char    bufwrk[BUFSIZE+1];
     char    delim;
     char    *p1;
     strcpy(bufwrk, str);
     memset(str, '\0', strlen(str)); //raz de la string qu'on va
     //reconstruire en substituant les QAN par leur equivalent symbol
     pstr1 = bufwrk;
     pmax = pstr1+strlen(pstr1);
     while ((p1=str_tok(pstr1, " \n\t", &delim, pmax))!=NULL)
     {
	       if (str_qalphanum (p1))
            if (!c_word(p1) && !is_yadvar(p1))
               if (exist_expresym(p1))
         {
                  strcat(str, "Ygs_");
         }
         strcat(str, p1);
         sprintf(str, "%s%c", str, delim);
	       pstr1 = pstr1+strlen(pstr1)+1;
     }
}

/*---------------------------------------------------------------------------*/
void substitut_produce_tab(char *instruct)
{    //on a detected qu'il y avait 1 (ou plusieurs) tableau dans instruct
     //on va les substituer, ..., mais avant, il faut les trouver ...
     char   *pstr1, *pstr2, *pstr3;
     char    bufwrk[BUFSIZE+1];
     char    strtab[LG_MAX_BIGVAR+1];
     int     idvar;
     int     semcro;
     char    yadvari[LG_MAX_NAME+1];
		 //printf("TAB(S) FOUND IN |%s|\n", instruct);

     strcpy(bufwrk, instruct);
     memset(instruct, '\0', strlen(instruct)); //raz d'instruct qu'on va
     //reconstruire en substituant les tableaux s'il y en a (risqued!?)

     fprintf(fpginac,"  cout<<endl;\n");

     pstr1 = bufwrk;
     while (1)
     {
        pstr2 = strchr(pstr1, '[');
        semcro=1;
        if (pstr2!=NULL)
        {  //pstr2 pointe sur le debut de tableau, il faut en trouver la fin
           pstr3=pstr2+1;
           while (1)
           {   pstr3=strpbrk(pstr3, "][");
               if (pstr3!=NULL)
               {
		              if (pstr3[0]=='[') ++semcro; else --semcro; //
		              ++pstr3;
                  if (pstr3[0]!='['  && semcro==0) break;
               }
               else break; //?
           }
           //rendu ici, pstr3 est sensed pointer sur l'octet qui suit le
           //crochet de fin du tableau

           //maintenant, on remonte pstr2 en arriere pour se mettre au debut
           //de la variable tableau
           while (pstr2[0]!=' ' && pstr2[0]!='\t' && pstr2[0]!='\n') --pstr2;

           //on met des /0 pour delimiter et creer la string tableau
           pstr2[0]='\0'; ++pstr2; //debut de la string tableau
           pstr3[0]='\0';          //fin de la string tableau
					 //printf ("->|%s|%s|%s|<-\n", pstr1, pstr2, pstr3+1); //pour verif du decoupage

	         strcpy(strtab, pstr2);
           str_lesschr(strtab, ' ');
					 //printf ("->|%s|<-\n", strtab);

           //ajout de ce tableau comme variable dans un tableaux de variable
           idvar = add_var(strtab);
           sprintf (yadvari, "Yadvar%i", idvar); //
           //creation du symbol pour le tableau
           fprintf(fpginac,"  symbol %s(\"%s\");\n", yadvari, yadvari);

           //declaration de la variable intermediaire pour backward
           fprintf(fpginac,"  cout<<\"double %s = %s;\"<<endl;\n", yadvari, strtab);

           //substitution : on reconstruit instruct (qu'on a razeder au debut)
           strcat(instruct, pstr1);
           strcat(instruct, " ");
           strcat(instruct, yadvari);

           //on repositionne pstr1 pour la suite, y'a peut etre encore d'autres tableaux?
           pstr1 = pstr3+1;
        }
        else
        {  strcat(instruct, pstr1);   //fin de reconstruction de instruct
           break;
        }
     }
}

/*---------------------------------------------------------------------------*/
void BackProduce_DAdx(char *instruct)
{    char   *pstr, *pmax;
     char   bufwrk[BUFSIZE+1];
     char   delim;
     char   *p1;
     char   DA_dx[LG_MAX_NAME*2+1];
     int    wi, idiff;
int nballin, startin;
nballin = NbIn+NbInCplx;
if (flagCPLX) startin=NbIn; else startin=0;

     strcpy(bufwrk, instruct);
     pstr = bufwrk;
     pmax = pstr+strlen(pstr);
     while ((p1=str_tok(pstr, " \n\t", &delim, pmax))!=NULL)
     {
	       if (str_qalphanum(p1))
            if (!c_word(p1) && !is_yadvar(p1))
				 {
//            for (wi=0; wi<NbIn; ++wi)
for (wi=startin; wi<nballin; ++wi)
            {
                sprintf(DA_dx, "YD%s_d%s", p1, TabExpreSym[wi]);
	              idiff = id_diff(DA_dx);
	              if (idiff<0) //ce qui veut dire qu'on rencontre DA_dx pour la 1ere fois
                {
                   if (NbDiff>=NB_MAX_DIFFVAR)
                   {  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
                      printf("       because :=> too much derivative in that modul\n");
                      exit(-9);
                   }
		               strcpy(TabDiff[NbDiff].vardiff, DA_dx);
		               TabDiff[NbDiff].deblockportee = CurBlockLev;
                   ++NbDiff;
                   fprintf(fpginac,"  cout<<\"double %s; \"<<endl;\n", DA_dx);
                }
                else //DA_dx existe deja, mais pour backward il faut eventuellement
                {    //produire de nouveau la declaration en tenant compte de l'imbrication des blocks !
                   if (TabDiff[idiff].deblockportee == 0)
                   {  TabDiff[idiff].deblockportee = CurBlockLev;
		                  fprintf(fpginac,"  cout<<\"double %s; \"<<endl;\n", DA_dx);
                   }
                }
            }
				 }
         pstr = pstr+strlen(pstr)+1;
     }
}

/*---------------------------------------------------------------------------*/
void Sto_GinProduce_ExpreSym(char *str)
{    char    *pstr, *pmax;
     char    bufwrk[BUFSIZE+1];
     char    delim;
     char    *p1;
     strcpy(bufwrk, str);
     pstr = bufwrk;
     pmax = pstr+strlen(pstr);
/*
short  vuegal=0;
printf("SGPESI: |%s|\n", instruct);
*/
     while ((p1=str_tok(pstr, " \n\t", &delim, pmax))!=NULL)
     {
/*
if (p1[0]=='=') vuegal=1;
*/
	       if (str_qalphanum(p1))
            if (!c_word(p1) && !is_yadvar(p1))
               if (!exist_expresym(p1))
               {
                  if (NbExpreSym>=NB_MAX_EXPRESYM)
                  {  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
                     printf("       because :=> too much token in that modul\n");
                     exit(-9);
                  }
/*nb: on est dans cette fct que si queaffect,
CELA N'EST SANS DOUTE PLUS VRAI
donc la variable n'a pas du faire l'objet
//    d'une declaration ce qui laisse penser qu'il s'agit d'une variable externe.
//    Si on est sur le token qui precede le '=', alors cela voudrait dire qu'on est en
//    train de de modifier cette variable externe, ce qui du coup modifie la fonction
//    elle meme, ce qui not fair et rend les testdf KO, --> WARNING
if (!vuegal)
{  printf("WARNING: you may be are modifying a extenal variable (%s) ...\n", p1);
   printf("         this is not fair and may make failed the validation functions test\n");
}
*/
                  strcpy(TabExpreSym[NbExpreSym], p1);
                  ++NbExpreSym;
		              fprintf(fpginac,"  ex %s;\n", p1);
		              fprintf(fpginac,"  symbol Ygs_%s(\"Ygs_%s\");\n", p1, p1);
               }
               pstr = pstr+strlen(pstr)+1;
     }
}

/*---------------------------------------------------------------------------*/
short dejadiff(char *var2diff)
{   //char   TabDejaDiff[NB_MAX_DIFFVAR][LG_MAX_NAME+1];
    //!!! tableau en global a usage local : initialement, et
		//    localement, mettre NbDejaDiff a ZERO !
    int	wi;
    for (wi=0; wi<NbDejaDiff; ++wi)
    {	if (!strcmp(var2diff, TabDejaDiff[wi]))
	       return (1);
    }
    return(0);
}

/*---------------------------------------------------------------------------*/
void GinBackProduce_dfDf(char *A, char *straffect) //A = straffect
{		 //maintenant, il faut produire les derivees.
     //1) il faut  produire dans ginac les derivee de tous les QAN de droite pour celui de gauche :
     //   ex avec : A = f(sB, sB, sC, ...)
     //   on doit obtenir : da_DB = A.diff(sB,1);  UNE SEULE FOIS
     //  										da_DC = A.diff(sC,1);	 ...
     //algo:
     // pour chaque variable (V) de straffect (en considerant qu'un token QAN !c_word et !yadvare est une variable (quid des constantes?)
     // construire da_DV
     // si dA_DV n'existe pas dans Tabdiff alors l'y ajouter et creer "ex da_DV;" pour ginac
     // produire pour ginac : "da_DV = A.diff(Ygs_V, 1);" une seule fois pour chaque variable
     char   *pstr, *pmax;
     char    bufwrk[BUFSIZE+1];
     char    delim;
     char    dA_DV[LG_MAX_NAME*2+1];
     int     idiff;
     char    *p1;

		 NbDejaDiff=0; //usage du tableau TabDejaDiff pour s'assurer qu'on ne derive qu'une seule fois une variable
		               //et meme si, lorsqu'en particulier elle apparait plusieurs fois en partie droite

     strcpy(bufwrk, straffect);
		 pstr = bufwrk;
     pmax = pstr+strlen(pstr);
     while ((p1=str_tok(pstr, " \n\t", &delim, pmax))!=NULL)
     {
	       if (str_qalphanum(p1))
            if (!c_word(p1) && !is_yadvar(p1))
         {
               sprintf(dA_DV, "Yd%s_D%s", A, p1);
	             idiff = id_diff(dA_DV);
	             if (idiff<0) //ce qui veut dire qu'on rencontre dA_DV pour la 1ere fois
               {
                  if (NbDiff>=NB_MAX_DIFFVAR)
                  {  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
                     printf("       because :=> too much derivative in that modul\n");
                     exit(-9);
                  }
		              strcpy(TabDiff[NbDiff].vardiff, dA_DV);
		              TabDiff[NbDiff].deblockportee = CurBlockLev;
                  ++NbDiff;
		              fprintf(fpginac,"  ex %s;\n", dA_DV);
                  fprintf(fpginac,"  cout<<\"double %s; \"<<endl;\n", dA_DV);
               }
               else //dA_DV existe deja, mais pour backward il faut eventuellement
               {    //produire de nouveau la declaration en tenant compte de l'imbrication des blocks !
                  if (TabDiff[idiff].deblockportee == 0)
                  {  TabDiff[idiff].deblockportee = CurBlockLev;
		                 fprintf(fpginac,"  cout<<\"double %s; \"<<endl;\n", dA_DV);
                  }
               }

							 //pour ne produire la derivee qu'une seule fois
							 if (!dejadiff(dA_DV))
               {  if (NbDejaDiff>=NB_MAX_DIFFVAR)
                  {  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
                     printf("       because :=> too much derivative in that modul\n");
                     exit(-9);
                  }
								  strcpy(TabDejaDiff[NbDejaDiff], dA_DV);
									++NbDejaDiff;
							    fprintf(fpginac,"  %s = %s.diff(Ygs_%s, 1);\n", dA_DV, A, p1);
                  fprintf(fpginac,"  cout<<\"%s = \" <<csrc<< %s <<\";\"<<endl;\n", dA_DV, dA_DV);
               }
         }
	       pstr = pstr+strlen(pstr)+1;
     }
}

/*---------------------------------------------------------------------------*/
void BackProduce_Dfdx(char *A, char *straffect)
{    //2) puis il faut produire la derivee du terme de gauche par rapport aux entrees.
     //   il s'agit de faire, directement dans le backward, la somme pour chaque entree xi :
     //             DA_dxi = dA_DV1.DV1_dxi + ... + dA_DVn.DVn_dxi
     char   *pstr, *pmax;
     char    bufwrk[BUFSIZE+1];
     char    delim;
     char    DA_dx[LG_MAX_NAME*2+1];
     int     wi;
     char    dA_DV[LG_MAX_NAME*2+1];
     int     idiff;
     char    *p1;
     char    DV_dx[LG_MAX_NAME*2+1];
int nballin, startin;
nballin = NbIn+NbInCplx;
if (flagCPLX) startin=NbIn; else startin=0;
     //pmax = straffect+strlen(straffect);
//---
//     for (wi=0; wi<NbIn; ++wi)
//for (wi=startin; wi<nballin; ++wi)
for (wi=0; wi<nballin; ++wi)
     {
if (TabFlagIn[wi]==-1) continue; //entree reelle comprise dans une entree complexe

         if (indicYS<=0) //(!isYSi)
         {
            sprintf(DA_dx, "YD%s_d%s", A, TabExpreSym[wi]);
	          idiff = id_diff(DA_dx);
	          if (idiff<0) //ce qui veut dire qu'on rencontre DA_dx pour la 1ere fois
            {
               if (NbDiff>=NB_MAX_DIFFVAR)
               {  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
                  printf("       because :=> too much derivative in that modul\n");
                  exit(-9);
               }
		           strcpy(TabDiff[NbDiff].vardiff, DA_dx);
		           TabDiff[NbDiff].deblockportee = CurBlockLev;
               ++NbDiff;
               fprintf(fpginac,"  cout<<\"double %s; \"<<endl;\n", DA_dx); //+pB
            }
            else //DA_dx existe deja, mais pour backward il faut eventuellement
            {    //produire de nouveau la declaration en tenant compte de l'imbrication des blocks !
               if (TabDiff[idiff].deblockportee == 0)
               {  TabDiff[idiff].deblockportee = CurBlockLev;
		              fprintf(fpginac,"  cout<<\"double %s; \"<<endl;\n", DA_dx);
               }
            }
         }
         else
            sprintf(DA_dx, "YJ%iI%i", indicYS, wi+1);
//---
         fprintf(fpginac,"  cout<<\"%s = \";", DA_dx);

				 NbDejaDiff=0;

   	     strcpy(bufwrk, straffect);
         pmax = bufwrk+strlen(bufwrk);
         pstr = bufwrk;
	       while ((p1=str_tok(pstr, " \n\t", &delim, pmax))!=NULL)
     	   {
	           if (str_qalphanum(p1))
            	 if (!c_word(p1) && !is_yadvar(p1))
             {
								  sprintf(dA_DV, "Yd%s_D%s", A, p1);
								  sprintf(DV_dx, "YD%s_d%s", p1, TabExpreSym[wi]); //.

							    //pour ne produire la derivee qu'une seule fois
									if (!dejadiff(dA_DV))
									{  if (NbDejaDiff>=NB_MAX_DIFFVAR)
										 {  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
											  printf("       because :=> too much derivative in that modul\n");
												 exit(-9);
											}
											strcpy(TabDejaDiff[NbDejaDiff], dA_DV);
											++NbDejaDiff;
                      if (!strcmp(p1, TabExpreSym[wi]))
                      {  //fprintf(fpginac,"  cout<<\"Yd%s_D%s + \";", A, p1);
									       fprintf(fpginac,"  cout<<\"%s + \";", dA_DV);
                      }
                      else if (id_input(p1)==-1) //(!is_input(p1))
                      {  //fprintf(fpginac,"  cout<<\"Yd%s_D%s*YD%s_d%s + \";", A, p1, p1, TabExpreSym[wi]);
                         if (id_diff(DV_dx)>=0) //on s'assure que DV_dx existe bien ...
											    fprintf(fpginac,"  cout<<\"%s*%s + \";", dA_DV, DV_dx);
                      }
									}
             }
 	           pstr = pstr+strlen(pstr)+1;
         }
	       fprintf(fpginac,"  cout <<\"0;\"<<endl;\n");
     }
}

/*----------------------------------------------------------------------------*/
/*============================================================================*/
void quedeclar (char *instruct, char *pstr2)
{  if (trace) printf("\n/*indicDECLAR & !indicAFFECT:|%s|%s|*/\n", instruct, pstr2);
   //un token de Type (double, float, ...) a ete rencontred et pstr2 pointe dessus
   //exemple soil_CG:         "} else { double ZFROZEN2;"
   //on va decouper l'instruction en 2 morceaux : Debut (instruct), et la declaration proprement dite (pstr2)
   pstr2[-1]='\0'; //nb: le token est en principe preceded d'au moins un ' ' ou '\t'
   //on produit le debut
   if (instruct<pstr2)
      BackwardOut(instruct); //d'abord le debut de l'instruction

   //on produit DAdx pour backward
   BackProduce_DAdx(pstr2);
	 //on stocke et produit pour ginac les QAN d'instruct dans TabExp si ils n'existe pas deja (ni en symbol)
   Sto_GinProduce_ExpreSym(pstr2);

   //on reconduit la suite (declaration proprement dite) tel quel pour backward
   BackwardOut(pstr2);
}

/*---------------------------------------------------------------------------*/
void quedeclar_cplx(char *instruct, char *pstr2)
{    char    *pstr, *pmax;
     char    bufwrk[BUFSIZE+1];
     char    delim;
     char    *p1;
     char    varcplx[LG_MAX_NAME+1];
		 short   flagvarcplx=0;
		 //short flagisinput=0;
		 short   idin1=-1,idin2=-1;

//exemple1:         "} else { complex < double > beta ( betr , beti ) ;"
//                            ^
//exemple2:         "} else { complex < double > beta ( betr , beti ), alpha ( ar , ai ), gamma;"
//                            ^
     pstr2[-1]='\0'; //nb: le token est en principe preceded d'au moins un ' ' ou '\t'
     //on produit le debut
     if (instruct<pstr2)
        BackwardOut(instruct); //d'abord le debut de l'instruction

     strcpy(bufwrk, pstr2);
     pstr = bufwrk;
     pmax = pstr+strlen(pstr);
     while ((p1=str_tok(pstr, " \t", &delim, pmax))!=NULL)
     {
		     if ((p1[0]==')' || p1[0]==';') && flagvarcplx==1)		// fin de la variable complexe precedente
				 {
						//a la fin, si flagisinput vaut 2 alors il s'agit une variable complexe d'entree
						//if (flagisinput==2)
						//Si idin1 et idin2 on une valeur d'indice alors (...) : variable complexe (d'entree?)
						if (idin1>=0 && idin2>=0)
						{  TabFlagIn[idin1] = TabFlagIn[idin2] = -1; //on neutralise ces entrees car c'est le complexe
								++NbInCplx;                               //associed qui devient la variable d'entree
								//idin1 = idin2 = -1;
								//flagvarcplx=0;
						}
						else	//sinon, il s'agit d'une variable intermediaire, on produit DAdx pour backward
						{  BackProduce_DAdx(varcplx);
						}

				    //re-init et passage a l'eventuelle variable suivante
				    flagvarcplx=0;
						idin1 = idin2 = -1;
            pstr = pstr+strlen(pstr)+1; //pour avancer sur la chaine de carateres
				    continue;
				 }

	       if (str_qalphanum(p1))
            if (!c_word(p1) && !is_yadvar(p1))
				 {
            if (!flagvarcplx)
						{  //on est sur le 1er token apres "double",  donc c'est sense etre le
						   //nom de la variable complexe beta

/*xxxxxxxxx
							 if (!exist_expresym(p1))
							 {  if (NbExpreSym>=NB_MAX_EXPRESYM)
									{  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
											printf("       because :=> too much token in that modul\n");
											exit(-9);
							    }
							    strcpy(TabExpreSym[NbExpreSym], p1);
							    ++NbExpreSym;
							    fprintf(fpginac,"  ex %s;\n", p1);
							    fprintf(fpginac,"  symbol Ygs_%s(\"Ygs_%s\");\n", p1, p1);
							 }
*/
							 Sto_GinProduce_ExpreSym(p1);
/*xxxxxxxxx
//             if (!exist_cplx(p1))
						   {  if (NbCplx>=NB_MAX_CPLX)
                  {  printf(" Ydf1: Automatic derivativ stopped for modul %s\n", ModulName);
                     printf("       because :=> too much complex token in that modul\n");
                     exit(-9);
                  }
                  strcpy(TabCplx[NbCplx], p1);
                  ++NbCplx;
							 }
*/
							 strcpy(varcplx, p1); //="beta"
						   flagvarcplx=1;
						}
						else
						{  //on est sur une des variables d'entree (betr ou beti) qui forme le complexe
						   //if (is_input(p1)) ++flagisinput;
							 if (idin1==-1) idin1=id_input(p1);
							 else idin2=id_input(p1);
						}

				 }
         pstr = pstr+strlen(pstr)+1;
     }

		 //on reconduit la suite (declaration proprement dite) tel quel pour backward
     BackwardOut(pstr2);
}


/*---------------------------------------------------------------------------*/
/*=============================================================================*/
void queaffect(char *instruct, char *pstr2)
{  char	  *pstr3;
   char	  affectsv[BUFSIZE+1];

	 if (trace) printf("\n/*indicAFFECT:|%s|%s|*/\n", instruct, pstr2);
   //des tokens d'affectation ('=', '+=', '-=', '*=', '/=')
   //on ete detected ... et pstr2 pointe dessus printf ("|%s|\n|%s|\n", instruct, pstr2);
	 //exemple:  "} else { double ZFROZEN2 = x1 ;"

   //si on a VAR {+,-,*,/}= EXPR; on va transformer en VAR = VAR {+,-,*,/} ( EXPR );
	 if (pstr2[0]=='+' || pstr2[0]=='-' || pstr2[0]=='*' || pstr2[0]=='/')
	 {  //printf("avant:|%s|%p|%c|\n", instruct, pstr2, pstr2[0]);
	    transfo_affect(instruct, pstr2); //(! modifie la chaine passed mais pstr2 doit pointer sur '=')
      //printf("apres:|%s|%p|%c|\n", instruct, pstr2, pstr2[0]);
	 }

	 //si les variables sont externes au module (une variable globale par exemple)
	 //il faut quand meme la declarer pour ginac
	 Sto_GinProduce_ExpreSym(instruct);

	 //ensuite, on va decouper l'instruction en 3 morceaux : Debut (instruct)  Variable(pstr3) Suite(pstr2)
   --pstr2;
   while ((pstr2[0]==' ' || pstr2[0]=='\t') && pstr2>instruct) --pstr2; //on remonte les espaces et \t
   pstr3=pstr2; //pstr3 va servire a pointer sur le debut de la variable affectee
   while (pstr3[0]!=' ' && pstr3[0]!='\t' && pstr3>instruct) --pstr3; //on remonte les autres caractères
	 if (pstr3>=instruct)  //si on est pas au debut de instruct
   {  pstr3[0]='\0'; //on met un '\0' avant la variable affected
      ++pstr3;
   }
   ++pstr2; pstr2[0]='\0'; //on met un '\0' apres la variable
   ++pstr2; //pour ne pas perdre la partie affectation de la suite de 'instruction
   //on devrait etre dans la situation suivante: ex:  "   if ( C1 ) " "A"    " = pow ( x , 2 ) , B ; "
	 //                                                  ^instruct       ^pstr3 ^pstr2

   //au passage, on interdit l'affectation des variables d'input ...!
   if (id_input(pstr3)!=-1) //(is_input(pstr3))
   {  printf (" Ydf1: Automatic derivative failed for modul %s\n", ModulName);
      printf ("       because :=> input values must not be changed !\n");
			exit (-9);
   }

   //positionnenemt d'un flag pour savoir s'il s'agit d'un YSi
   indicYS = id_YSi(pstr3);

   //puis on produit pour backward
	 if (instruct<pstr3) BackwardOut(instruct); //d'abord le debut de l'instruction (si different de pstr3)
   if ((indicBLOCK-indicCROUV)>0) //if (indicBLOCK && !indicCROUV)
   {  fprintf(fpginac,"  cout << \"{\"<<endl;\n"); //et eventuellement, on rajoute un crochet ouvrant ('{')
      ++CurBlockLev; //printf("+CurBlockLev=%i\n", CurBlockLev);
   }

   //si on a detecter un tableau on passe et on le remplace par une variable intermediaire
	 if (indicTAB) substitut_produce_tab(pstr2); // puis les tableaux s'il y a lieu (! modifie la chaine passed)

	 //pour ginac il faut reconduire l'affectation en remplacant les variables de la partie droite par des symbols
   //on sauvegarde donc cette partie droite car on devra la reproduire pour backward mais seulement apres les derivee
   strcpy(affectsv, pstr2);    //sauvegarde pour backward
	 substitut_by_symbol(pstr2); //on remplace les QAN par leur equivalent symbol(! modifie la chaine passed)
   fprintf(fpginac,"  %s %s\n", pstr3, pstr2); //et on produit pour ginac

	 //maintenant, il faut calculer les derivees.
   //1) il faut  produire dans ginac les derivee de tous les QAN de droite pour celui de gauche :
   //   ex avec : A = f(sB, sB, sC, ...)
   //   on doit obtenir :  da_DB = A.diff(sB,1);  UNE SEULE FOIS
   //  										 da_DC = A.diff(sC,1);			...
	 GinBackProduce_dfDf(pstr3, affectsv);

   //2) puis il faut produire dans le backward directement, la derivee du terme de gauche par rapport aux entrees.
   //   il s'agit de faire, la somme pour chaque entree xi :
   //             DA_dxi = dA_DV1.DV1_dxi + ... + dA_DVn.DVn_dxi
	 BackProduce_Dfdx(pstr3, affectsv);

   //on termine par l'affectation pour backward (sauf pour YSi a moins que level>=9 !?)
   if (indicYS<=0 || (indicYS>0 && prodlevel>=9))
   {
			BackwardOut(pstr3);          //la variable
      fprintf(fpginac,"  cout <<\" \";\n"); //(un espace separateur?)
			BackwardOut(affectsv);       //puis la suite (partie affectation prealablement sauvegarded)
   }

	 //eventuellement, il faut terminer par une accolade fermante ('}')
   if ((indicBLOCK-indicCROUV)>0) //if (indicBLOCK && !indicCROUV)
   {  fprintf(fpginac,"  cout <<endl<< \"}\"<<endl;\n");
      decrem_diff_blocklev(); //--CurBlockLev; //printf("+CurBlockLev=%i\n", CurBlockLev);
   }
}
/*----------------------------------------------------------------------------*/
/*============================================================================*/
void declaretaffect (char *instruct, char *pstr2)
{  //declaration et affectation: ex : if (... double A=vglob1, B=pow(A,2), C, D=A*vglob2;
   //pstr2 pointe sur le type
	 char   *p3;
	 char   *paffect;
	 char   winst[BUFSIZE +1];
	 int    entre;
	 int    wi, last;
	 int    blockindic=0;

   if (trace) printf("\n/*indicDECLAR & indicAFFECT:|%s|%s|*/\n", instruct, pstr2);

   //on produit le debut
	 pstr2[-1]='\0'; //nb: le token est en principe preceded d'au moins un ' ' ou '\t'
   if (instruct<pstr2) BackwardOut(instruct); //d'abord le debut de l'instruction (si different de pstr2)

   //puis ici, y'a peut etre bien des crochet ....
   if ((indicBLOCK-indicCROUV)>0) //if (indicBLOCK && !indicCROUV)
   {  fprintf(fpginac,"  cout << \"{\"<<endl;\n"); //et eventuellement, on rajoute une accolade ouvrante ('{')
      ++CurBlockLev; //printf("+CurBlockLev=%i\n", CurBlockLev);
			//et on neutralise le flag indicBLOCK pour pas avoir des accolades en double par la fct queaffect()
	    //blockindic=1; indicBLOCK=0;
			blockindic=indicBLOCK;  indicBLOCK=indicCROUV;
   }

	 //on se positionne a la fin du type pour l'isoler
	 p3 = pstr2;
	 while (p3[0]!=' ' && p3[0]!='\t') ++p3;
	 p3[0]='\0';
	 ++p3;

	 //puis, on remplace toutes les ',' qui ne sont pas entre ({[]}) par ';'
	 //a partir de p3
	 entre = 0;
	 wi=0; last=0;
	 while (!last)
	 {   if (p3[wi]==';') last=1;

	     if (p3[wi]=='(' || p3[wi]=='{' || p3[wi]=='[') ++entre;
	     if (p3[wi]==')' || p3[wi]=='}' || p3[wi]==']') --entre;
			 if (p3[wi]==',' && entre==0) p3[wi]=';';

			 if (p3[wi]==';') //il faut traiter le cas   icicicicici
			 {  if (!last) p3[wi+1]='\0';
			    if ((paffect = str_affect(p3)) != NULL)
					{  //on traite l'aspect declaration
					   paffect[-1] = '\0'; //ca isole la variable
						 sprintf(winst, " %s %s ;\n", pstr2, p3); //on formate la declaration
						 quedeclar(winst, winst);						      //et on la traite

						 //on traite l'aspect affectation
						 sprintf(winst, " %s %s \n", p3, paffect);
						 paffect = str_affect(winst);
						 queaffect(winst, paffect);
					}
          else // il ne s'agit que d'une declarartion
					{   sprintf(winst, " %s %s \n", pstr2, p3); //on formate la declaration
						  quedeclar(winst, winst);						     //et on la traite
					}

					p3 = &p3[wi+2]; //equiv: p3 = p3+wi+2;
					wi = 0;
			 }
			 else
			    ++wi;
	 }

   //eventuellement, on ajoute une accolade fermante ('}') et on restaure le flag indicBLOCK
   if (blockindic) //(blockindic>0)
   {  fprintf(fpginac,"  cout <<endl<< \"}\"<<endl;\n");
      decrem_diff_blocklev(); //--CurBlockLev; //printf("+CurBlockLev=%i\n", CurBlockLev);
      indicBLOCK=blockindic; //indicBLOCK=1;
   }

	 //printf("\n/*indicDECLAR & indicAFFECT:|%s|%s|*/\n", instruct, pstr2);
}

/*=============================================================================*/
/* en entree : un nom de module.h qui est sensee contenir une fonction forward */
/* en sortie : un programme qui saura generer une fonction backward            */
/*=============================================================================*/
/*---------------------------------------------------------------------------*/
int main (int argc, char *argv[])
{  //syntaxe: Ydf1 wrk_modul_in_file_name  module  nbin  nbout  [prodlevel]
	int     nbinfound=0;
  char    *paffect;
	char	  *pstr1;
  char	  *pstr2=NULL;
	char	  modul_file_name[LG_MAX_NAME+1];
	int     lenmodulname;
  printf("Ydf1:id:3\n");

   /* debut : verif arg, ouverture fichier ... :::::::::::::::::::::::::::::::*/
  if (argc < 5 || argc > 6)
	{  printf (" Ydf1: Syntaxe error: Ydf1 modul_file_name module_name nbin nbout [prodlevel]}\n");
	   exit(-9);
	}

	strcpy(modul_file_name, argv[1]);
	if ((fpmodul = fopen(modul_file_name, "r")) <= 0)
	{  printf (" Ydf1: In file (%s) not found \n", argv[1]);
	   exit(-9);
	}

  if (argc==6)
  {  prodlevel=atoi(argv[5]);
  }

  NbIn  = atoi(argv[3]);
  NbOut = atoi(argv[4]);

  /*-----*/
	if ((fpginac = fopen("Y37wrk.cc", "w")) <= 0)
	{  printf (" Ydf1: Pb when opening out file (Y37wrk.cc)\n");
	   exit(-9);
	}
  /*-----*/

	//on recupere le nom du module (pour apres)
	strcpy(ModulName, argv[2]);					//en enlevant
	lenmodulname = strlen(ModulName);   //eventuellement .h
	if (ModulName[lenmodulname-1]=='h' && ModulName[lenmodulname-2]=='.')
	   ModulName[lenmodulname-2]='\0';

  /* entête */
  fprintf (fpginac, "#include <iostream>\n");
  fprintf (fpginac, "#include <ginac/ginac.h>\n");
  fprintf (fpginac, "using namespace std;\n");
  fprintf (fpginac, "using namespace GiNaC;\n");
  fprintf (fpginac, "int main()\n");
  fprintf (fpginac, "{\n");

  memset(instruct, '\0', BUFSIZE+1); //instruct[0]='\0';

  /* boucle de lecture du module */
  while (  (fgets(buffer, BUFSIZE+1, fpmodul)) != NULL)
  {   //printf("lu|%s|\n", buffer);

		  pstr1 = strtok(buffer, delim);
      while (pstr1!=NULL)
      {   //printf("pstr1=|%s|\n", pstr1);

          if (!strcmp(pstr1, "{")) ++CurBlockLev;
          if (!strcmp(pstr1, "}")) decrem_diff_blocklev(); //--CurBlockLev; //printf("CurBlockLev=%i\n", CurBlockLev);
          //----------------------------------------------------------
          //traitement ligne forward
 					//----------------------------------------------------------
          if (Phase==0 && !strcmp(pstr1, "forward"))
          {  Phase=1;
          }
          else if (Phase==1)
          {  if (!strcmp(pstr1, "{")) //if (pstr1[0]=='{')
             {
                if (nbinfound != NbIn)
                {  printf (" Ydf1: Automatic derivative failed for modul %s\n", ModulName);
                   printf ("       because :=> Desagree on input: found %i expected %i\n", nbinfound, NbIn);
									 exit (-9);
                }
                fprintf(fpginac, "  cout << \"void %s::backward (", ModulName);
                for (k=0; k<NbIn-1; ++k)
                    fprintf(fpginac, "YREAL  %s, ", TabExpreSym[k] );
                fprintf(fpginac, "YREAL  %s ", TabExpreSym[k] );
                fprintf(fpginac, ")\"<<endl<<\"{\";\n");

                Phase=2;
								strcpy(delim," \t");  //delimiteur pour la PHASE 2
             }
             else
             {  //traitement ligne forward : symbole d'input
                if (strcmp(pstr1, "YREAL"))
                {  //chouette voici un symbole d'input //printf ("symbol=%s\n", pstr1);
									 Sto_GinProduce_ExpreSym(pstr1);
                   ++nbinfound;
               }
             }
          }
					//----------------------------------------------------------
          // fin ligne forward, maintenant il s'agit de traiter le corps
					//----------------------------------------------------------
          //algo : on stock les tokens dans une chaine jusqu'a un ';'
				  else if (Phase==2)
          {
							//stockage (par concatenation) des tokens dans la chaine instruct
						  sprintf (instruct, "%s %s", instruct, pstr1);

              //indicateurs ...
              if      (!strcmp(pstr1, "complex"))
              {  flagCPLX=1;
							   //ne pas casser pstr2 si deja positionned
								 if (pstr2==NULL) //if (!indicAFFECT) //sinon il doit s'agir d'un cast
							   {  pstr2=instruct+strlen(instruct)-strlen(pstr1);
								    indicDECLAR = 1;
								 }
              }
              else if (!strcmp(pstr1, "if"))      ++indicBLOCK; //indicBLOCK  = 1;
              else if (!strcmp(pstr1, "else"))    ++indicBLOCK; //indicBLOCK  = 1;
              else if (!strcmp(pstr1, "while"))   ++indicBLOCK; //indicBLOCK  = 1;
              else if (!strcmp(pstr1, "for"))     ++indicBLOCK; //indicBLOCK  = 1;
              else if (!strcmp(pstr1, "{"))       ++indicCROUV; //indicCROUV  = 1;
              else if (strchr(pstr1, '[')!=NULL)  indicTAB    = 1;
              else if ( !strcmp(pstr1, "YREAL") || !strcmp(pstr1, "double")  || !strcmp(pstr1, "int")
              ||        !strcmp(pstr1, "long")  || !strcmp(pstr1, "float")
                      )
              {  //ne pas casser pstr2 si deja positionned
							   if (pstr2==NULL) //if (!indicAFFECT) //sinon il doit s'agir d'un cast
							   {  pstr2=instruct+strlen(instruct)-strlen(pstr1);
								    indicDECLAR = 1;
								 }
              }

							paffect = str_affect(pstr1);
							if (paffect != NULL)
							{  //if (!indicAFFECT && !indicDECLAR) //... ne pas casser pstr2 si deja positionned
							   if (pstr2==NULL) //... ne pas casser pstr2 si deja positionned
							   {  //pstr2 = paffect;
								    pstr2 = instruct+strlen(instruct)-strlen(paffect);
								 }
							   indicAFFECT = 1;
							}

              //au passage, on s'assurer qu'YS* n'apparait pas en partie droite
              //because c'est pas pratique a gerer, mais ce peut etre une source d'erreur !!!??? ...
              if  (indicAFFECT || indicDECLAR) //on est donc soit deja en partie droite d'une affectation,
              {                                //soit sur une declaration et la aussi YSi ne doit pas apparaitre
          			  if (id_YSi(pstr1)>0)
                  {  printf (" Ydf1: Automatic derivative failed for modul %s\n", ModulName);
                     printf ("       because :=> YSi must not appears neither on declaration or on right side of an affectation !\n");
									   exit (-9);
                  }
              }

	            //fin de constitution de la chaine; il faut traiter
              if  (!strcmp(pstr1, ";"))
              {
                  if (indicDECLAR && !indicAFFECT)  //=> SI QUE DECLAR
									{	 if (flagCPLX)											 //ex:  " if ( C1 ) complex < double > A ( rA , iA ) ; "
									      quedeclar_cplx(instruct, pstr2); //                           ^
									   else //cas 'normal'
										    quedeclar(instruct, pstr2);   //ex:  " if ( C1 ) double A ; "
																										  //      ^instruct  ^pstr2
									}
                  else if (indicDECLAR) //=> SI DECLAR ET AFFECT
                  {  declaretaffect(instruct, pstr2); //ex:  "if ( C1 )  double A = pow ( x , 2 ) , B ; "
									}                                   //      ^instruct  ^pstr2
									else if (indicAFFECT) //=> SI QUE AFFECT
                  {   queaffect(instruct, pstr2);     //ex:  "   if ( C1 )  A = pow ( x , 2 ) , B ; "
									}                                   //      ^instruct       ^pstr2
                  else
                  {  // ???!!!! reconduit-on ou pas tel quel !!!???
                     if (prodlevel==1 || prodlevel>2)
                     {  //on reproduite tel quel, QUE pour BACKWARD et donc RIEN pour GINAC.
                        //il doit s'agir de ce genre d'instruction dont on ne sait que faire
                        //pour la derivation comme *printf*, *str*, *get*, *scan*, io, ...

                        //j'ai un pb avec les " exemple :  strcpy ( toto , "toto" ) ; ...
                        //ca devrait etre regled
                        //printf("  cout << \"%s\";\n", instruct);
												BackwardOut(instruct); //par contre c'est ok pour par exemple:  strcpy(toto,titi);
                     }
                  }

                  //re-init pour instruction suivante
                  indicBLOCK=indicCROUV=indicTAB=indicAFFECT=indicDECLAR=indicYS=0; //re-init des indicateurs
									pstr2=NULL;
                  memset(instruct, '\0', BUFSIZE+1); //reinit de instruct
              }//fin de if ';'
					}//fin du if Phase 2
			    //passer au token suivant
          pstr1 = strtok(NULL, delim);
     }
  }
  BackwardOut(instruct); //pour reconduire la fin du code pour backward qui peut (et
                         //devrait) consister des carateres de terminaison de block ('}')

	//fprintf(fpginac, "  } \n\n", pstr2); // fin pour ginac
	fprintf(fpginac, "  } \n\n"); // fin pour ginac
  exit(0);
}