#define MAX_TAG_STACK          80              //Nombre de tag dans la pile d'expressions de base
#define MAX_OPERATOR_STACK    20              //Nombre d'opérateurs maximum dans la pile d'opérateurs
s_tag StackTag [MAX_TAG_STACK];               //Pile d'expressions de départ
s_tag TStackTag [MAX_TAG_STACK];               //Pile d'expressions triée
s_tag *OperatorStack [MAX_OPERATOR_STACK];     //Pile temporaire d'opérateurs
unsigned char StackTagPtr, TStackTagPtr;

//Liste des variables
lstring GFA_vars [256];
unsigned char GFA_indexvar=0;

#define MAX_SIZE_VAR      16

#define TAG_UNKNOWN        0x00
#define TAG_VAR            0x01
#define TAG_NUMBER        0x02
  #define TAG_INT            0x00
  #define TAG_BOOL          0x01
  #define TAG_FLOAT          0x02
  #define TAG_CHAR          0x03
#define TAG_NEG            0x03 
#define TAG_ADD            0x04
#define TAG_SUB            0x05
#define TAG_MUL            0x06
#define TAG_DIV            0x07
#define TAG_PUISS          0x08
#define TAG_EGAL          0x09
#define TAG_SUPERIOR      0x0A
#define TAG_INFERIOR      0x0B
#define TAG_SUPEGAL        0x0C
#define TAG_INFEGAL        0x0D
#define TAG_DIFF          0x0E
#define TAG_STRING        0x0F
#define TAG_VIRGULE        0x10
#define TAG_PARENTH0      0x11  //(
#define TAG_PARENTH1      0x12  //)

#define TAG_PRIORITY_0    0x00
#define TAG_PRIORITY_1    0x01
#define TAG_PRIORITY_2    0x02
#define TAG_PRIORITY_3    0x03
#define TAG_PRIORITY_4    0x04
#define TAG_PRIORITY_5    0x05
#define TAG_PRIORITY_6    0x06
#define TAG_PRIORITY_7    0x07


//********************************************
//Analyse un programme et le transforme en Tags
//*********************************************
BOOL GFA_Scanner_ReadFile (lstring source)
{  
  char *ptr = source.data;
  long size = source.size;
  
  s_tag tag;
  GFA_Scanner_NextTag (&tag, ptr);
  unsigned char preview_tag = TAG_UNKNOWN;
  
  error_line = 1;
  
  GFA_indexvar = 0;    //Pointeur de variables type int
  StackTagPtr = 0;
  
  while (size-->0 && error_code==ERROR_NOERROR)
  {
    //Variable
    if ((*ptr>='A' && *ptr<='Z') || (*ptr>='a' && *ptr<='z') || *ptr=='_')
    {
      if (preview_tag==TAG_STRING || tag.type==TAG_NUMBER 
      || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT)
      || (preview_tag==TAG_VAR && tag.string.size==0)) 
        {error_code = ERROR_SYNTAX; break;}    
      else if (tag.string.size==MAX_SIZE_VAR) 
        {error_code = ERROR_VARTOOLONG; break;}
      
      //)var ajouter signe multiplier
      if (preview_tag==TAG_PARENTH1) GFA_Scanner_ADD_TagInStack (TAG_MUL, TAG_UNKNOWN, NULL, 0);
      
      if (tag.string.size==0) {tag.type = TAG_VAR; tag.subtype = TAG_FLOAT;} 
      tag.string.size++; preview_tag = TAG_VAR;
    }
    //Nombre
    else if (*ptr>='0' && *ptr<='9')
    {
      if (preview_tag==TAG_STRING 
      || (preview_tag==TAG_VAR && tag.string.size==0))
        {error_code = ERROR_SYNTAX; break;}
      else if (tag.type==TAG_VAR && tag.string.size==MAX_SIZE_VAR) 
        {error_code = ERROR_VARTOOLONG; break;}
      
      //)var ajouter signe multiplier
      if (preview_tag==TAG_PARENTH1) GFA_Scanner_ADD_TagInStack (TAG_MUL, TAG_UNKNOWN, NULL, 0);

      if (tag.string.size==0) {tag.type = TAG_NUMBER; tag.subtype = TAG_INT;}
      else if (tag.type==TAG_UNKNOWN) tag.type = TAG_NUMBER;  
      tag.string.size++;  preview_tag = tag.type;
    }
    //Virgule flottante
    else if (*ptr=='.')
    {
      if ((preview_tag==TAG_VAR || preview_tag==TAG_STRING || tag.subtype==TAG_FLOAT)) 
        {error_code = ERROR_SYNTAX; break;}
      
      //Forme ). ajouter signe multiplier
      if (preview_tag==TAG_PARENTH1) GFA_Scanner_ADD_TagInStack (TAG_MUL, TAG_UNKNOWN, NULL, 0);
      tag.subtype = TAG_FLOAT;
      tag.string.size++; preview_tag = TAG_FLOAT;
    }
    //Typage
    else if (*ptr=='%' || *ptr=='$' || *ptr=='!')
    {
      unsigned char code = TAG_UNKNOWN;
      switch (*ptr)
      {
        case '!':code = TAG_BOOL; break;
        case '$':code = TAG_CHAR; break;
        case '%':code = TAG_INT; break;
      }
      
      if (preview_tag!=TAG_VAR 
      || (preview_tag==TAG_VAR && tag.string.size==0)) 
        {error_code = ERROR_SYNTAX; break;}
      
      GFA_Scanner_ADD_TagInStack (tag.type, code, tag.string.data, tag.string.size);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = TAG_VAR;
    }
    //Signes
    else if (*ptr=='+' || *ptr=='-' || *ptr=='*' || *ptr=='/' || *ptr=='^')
    {
      unsigned char code = TAG_UNKNOWN;
      switch (*ptr)
      {
        case '+':code = TAG_ADD; break; //Utiliser pour concantaner des chaînes de caractères
        case '-':code = TAG_SUB; break;
        case '*':code = TAG_MUL; break;
        case '/':code = TAG_DIV; break;
        case '^':code = TAG_PUISS; break;
      }
      
      if ((tag.string.size==0 && preview_tag!=TAG_VAR && preview_tag!=TAG_STRING && preview_tag!=TAG_PARENTH1) 
       || (code!=TAG_ADD && preview_tag==TAG_STRING)
       || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT))
        {error_code = ERROR_SYNTAX; break;}
      else if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size);
      GFA_Scanner_ADD_TagInStack (code, TAG_UNKNOWN, ptr, 1);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = code;
    }
    //Egalité, affectation, signes
    else if (*ptr=='=' || *ptr=='<' || *ptr=='>')
    {
      unsigned char code = TAG_UNKNOWN;
      switch (*ptr)
      {
        case '=':code = TAG_EGAL; break;
        case '<':code = TAG_INFERIOR; break;
        case '>':code = TAG_SUPERIOR; break;
        
        //Caractère provisoire
        case 22: code = TAG_EGAL; break;
      }
      
      if ((tag.string.size==0 && preview_tag!=TAG_VAR && preview_tag!=TAG_STRING && preview_tag!=TAG_SUPERIOR && preview_tag!=TAG_INFERIOR && preview_tag!=TAG_PARENTH1) 
       || (code==TAG_INFERIOR && (preview_tag==TAG_EGAL || preview_tag==TAG_SUPERIOR || preview_tag==TAG_INFERIOR))
       || (code==TAG_SUPERIOR && preview_tag==TAG_SUPERIOR)
       || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT))
      {error_code = ERROR_SYNTAX; break;}
      
      //Condition type >= ou <= ou <>
      if ((code==TAG_EGAL || code==TAG_SUPERIOR) && (preview_tag==TAG_SUPERIOR || preview_tag==TAG_INFERIOR))
      {
        //>= ou <=
        if (code==TAG_EGAL)
        {
          if (preview_tag==TAG_SUPERIOR) code = TAG_SUPEGAL;
          else code = TAG_INFEGAL;
        }
        //<>
        else code = TAG_DIFF;
        
        //Modification de la pile d'instructions double signe
        StackTag [StackTagPtr].type = code;
        StackTag [StackTagPtr].string.size++; 
      }
      //Simple caractère 
      else 
      {
        if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size);
        GFA_Scanner_ADD_TagInStack (code, TAG_UNKNOWN, ptr, 1);
      }
      
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = code;
    }
    //Négatif
    else if (*(unsigned char *)ptr==173)
    {
      if (tag.string.size!=0 || preview_tag==TAG_VAR || preview_tag==TAG_NEG || preview_tag==TAG_STRING) 
        {error_code = ERROR_SYNTAX; break;}
      
      //Forme )- ajouter signe multiplier 
      if (preview_tag==TAG_PARENTH1) GFA_Scanner_ADD_TagInStack (TAG_MUL, TAG_UNKNOWN, NULL, 0);
      GFA_Scanner_ADD_TagInStack (TAG_NEG, TAG_UNKNOWN, ptr, 1);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = TAG_NEG;
    }
    //Virgule
    else if (*ptr==',')
    {
      //Caractère de début
      if ((tag.string.size==0 && preview_tag!=TAG_VAR && preview_tag!=TAG_STRING && preview_tag!=TAG_VIRGULE && preview_tag!=TAG_PARENTH1 && preview_tag!=TAG_UNKNOWN) 
       || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT)) 
        {error_code = ERROR_SYNTAX; break;}
      
      if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size);
      GFA_Scanner_ADD_TagInStack (TAG_VIRGULE, TAG_UNKNOWN, ptr, 1);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = TAG_VIRGULE;
    }
    //Parenthèse ouverte TAG_PARENTH0
    else if (*ptr=='(')
    {
      if (preview_tag==TAG_STRING
      || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT))
        {error_code = ERROR_SYNTAX; break;}
      
      //Forme x( ajouter signe multiplier
      if (preview_tag==TAG_NUMBER || preview_tag==TAG_PARENTH1)  GFA_Scanner_ADD_TagInStack (TAG_MUL, TAG_UNKNOWN, NULL, 0);
      
      if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size);
      GFA_Scanner_ADD_TagInStack (TAG_PARENTH0, TAG_UNKNOWN, ptr, 1);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = TAG_PARENTH0;
    }
    //Parenthèse fermée TAG_PARENTH1
    else if (*ptr==')')
    {
      if (tag.string.size==0 && preview_tag!=TAG_VAR && preview_tag!=TAG_STRING && preview_tag!=TAG_PARENTH0 && preview_tag!=TAG_PARENTH1)
        {error_code = ERROR_SYNTAX; break;}
        
      if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size);
      GFA_Scanner_ADD_TagInStack (TAG_PARENTH1, TAG_UNKNOWN, ptr, 1);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = TAG_PARENTH1;
    }
    //Espace
    else if (*ptr==32)
    {
      //Caractère de début
      if ((tag.string.size==0 && preview_tag!=TAG_VAR && preview_tag!=TAG_STRING && preview_tag!=TAG_PARENTH1 && preview_tag!=TAG_UNKNOWN) 
       || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT)) 
        {error_code = ERROR_SYNTAX; break;}
        
      if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = TAG_UNKNOWN;
    }
    //Commentaires 'comment
    else if (*ptr==39)
    {      
      if ((tag.string.size==0 && preview_tag!=TAG_VAR && preview_tag!=TAG_STRING && preview_tag!=TAG_PARENTH1 && preview_tag!=TAG_UNKNOWN)
      || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT)) 
        {error_code = ERROR_SYNTAX; break;}
      
      if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size);

      //Cherche caractère 13 ou fin du fichier
      while (--size && *++ptr!=13);
      error_line++;
      GFA_Scanner_NextTag (&tag, ++ptr+1); size--;
      preview_tag = TAG_UNKNOWN;
    }
    //Chaîne de caractères
    else if (*ptr==34)
    {
      if (tag.string.size!=0 || preview_tag==TAG_VAR || preview_tag==TAG_SUB || preview_tag==TAG_MUL || preview_tag==TAG_DIV || preview_tag==TAG_PUISS || preview_tag==TAG_STRING || preview_tag==TAG_PARENTH1) 
        {error_code = ERROR_SYNTAX; break;}
      
      do
      {
        ptr++;
        //Fin d'une châine de caractères
        if (*ptr==34) break;
        //Saut à la ligne
        else if (*ptr==13) {error_code = ERROR_SYNTAX; break;}
        
        tag.string.size++; 
      } while (--size);
      
      //Fin du fichier
      if (size--==0) error_code = ERROR_SYNTAX;
      
      GFA_Scanner_ADD_TagInStack (TAG_STRING, TAG_UNKNOWN, ++tag.string.data, tag.string.size);
      GFA_Scanner_NextTag (&tag, ptr+1);
      preview_tag = TAG_STRING;
    }
    //Caractère inconnu
    else if (*ptr!=13) error_code = ERROR_UNKNOWNCHAR;
    
    //Aller à la ligne
    if (*ptr==13 || !size)
    {
      if (error_code!=ERROR_NOERROR) break;  
      else if ((tag.string.size==0 && preview_tag!=TAG_VAR && preview_tag!=TAG_STRING && preview_tag!=TAG_PARENTH1 && preview_tag!=TAG_UNKNOWN)
       || (tag.type==TAG_UNKNOWN && tag.subtype==TAG_FLOAT)) 
        {error_code = ERROR_SYNTAX; break;}  
      
      if (tag.string.size!=0) GFA_Scanner_ADD_TagInStack (tag.type, tag.subtype, tag.string.data, tag.string.size); 
      
      //Analyse
      if (!GFA_Scanner_SET_TagInStack ()) break;
      
      //Ligne suivante
      if (*ptr==13) {error_line++; ptr++; size--;}
      
      GFA_Scanner_NextTag (&tag, ptr+1); 
      preview_tag = TAG_UNKNOWN;
    }
    
    
    ptr++;
  }
  
  if (error_code!=ERROR_NOERROR) {error_ptr = size; return FALSE;}
  return TRUE;
}


//****************************
//Prepare instruction suivante
//****************************
void GFA_Scanner_NextTag (s_tag *tag, void *ptr)
{
  tag->type = TAG_UNKNOWN;
  tag->subtype = TAG_UNKNOWN;  
  tag->string.data = ptr;
  tag->string.size = 0;
}


//*******************************
//Ajoute instructions sur la pile
//*******************************
BOOL GFA_Scanner_ADD_TagInStack (unsigned char type, unsigned char subtype, void *data, unsigned short size)
{
  //Dépassement de la pile
  if (StackTagPtr+1==MAX_TAG_STACK) {
    error_code = ERROR_LINETOOLONG;
    return FALSE;}
  
  //Ajoute instruction dans la pile
  StackTag [StackTagPtr].type = type;
  StackTag [StackTagPtr].subtype = subtype;
  StackTag [StackTagPtr].string.data = data;
  StackTag [StackTagPtr].string.size = size;
  
  GFA_Scanner_SetPriority_TagInStack (StackTagPtr++);
  return TRUE;
}


//********************************
//Attribution priorité
//********************************
void GFA_Scanner_SetPriority_TagInStack (unsigned char ptr)
{
  unsigned char type = StackTag [ptr].type;
  
  if (type==TAG_INFERIOR || type==TAG_SUPERIOR || type==TAG_EGAL || type==TAG_SUPEGAL || type==TAG_INFEGAL || type==TAG_DIFF)
    StackTag [ptr].priority = TAG_PRIORITY_0;
  else if (type==TAG_ADD || type==TAG_SUB)
  {
    if (ptr && type==TAG_ADD && StackTag [ptr-1].type==TAG_STRING) 
      StackTag [ptr].priority = TAG_PRIORITY_1;
    else 
      StackTag [ptr].priority = TAG_PRIORITY_2;
  }
  else if (type==TAG_MUL || type==TAG_DIV)
    StackTag [ptr].priority = TAG_PRIORITY_3;
  else if (type==TAG_NEG)
    StackTag [ptr].priority = TAG_PRIORITY_4;
  else if (type==TAG_PUISS)
    StackTag [ptr].priority = TAG_PRIORITY_5;
}


//********************************
//Mise en ordre de la pile
//********************************
BOOL GFA_Scanner_SET_TagInStack ()
{
  unsigned char OperatorStackPtr=0;
  TStackTagPtr = 0; //Vide la pile temporaire
  
  //OperatorStack
  unsigned char tag_type = TAG_UNKNOWN;
    
  //Parcours la pile d'expression de base
  for (int i=0; i<StackTagPtr; i++)
  {
    tag_type = StackTag .type;
    
    //Simple nombre ou variable, ajoute dans la pile d'expressions finale
    if (tag_type==TAG_NUMBER || tag_type==TAG_VAR || tag_type==TAG_STRING)
      memcpy (&TStackTag [TStackTagPtr++], &StackTag [i], sizeof (s_tag)); 
  
    //Parenthèse ouverte, ajoute dans la pile d'opérateurs  
    else if (tag_type==TAG_PARENTH0)
      OperatorStack [OperatorStackPtr++] = &StackTag [i];
      
    //Parenthèse fermée, ajouter dernier signe dans pile d'expreesions finale puis tester si parenthèse ouverte
    else if (tag_type==TAG_PARENTH1)
    {
      //Ajoute signe opérateur dans la pile d'expressions
      while (OperatorStackPtr-- && OperatorStack [OperatorStackPtr]->type!=TAG_PARENTH0)  
        memcpy (&TStackTag [TStackTagPtr++], OperatorStack [OperatorStackPtr], sizeof (s_tag));
      
      //Parenthèse non trouvée
      if (OperatorStack [OperatorStackPtr]->type!=TAG_PARENTH0) 
        {error_code = ERROR_SYNTAX; break;}
    }
    
    //Opérateurs
    else if (tag_type!=TAG_VIRGULE)
    {
      //Ajoute signe opérateur dans la pile d'expressions
      if (OperatorStackPtr && OperatorStack [OperatorStackPtr-1]->type!=TAG_PARENTH0)
      {
        //Echange opérateurs
        if (StackTag [i].priority<=OperatorStack [OperatorStackPtr-1]->priority) 
          memcpy (&TStackTag [TStackTagPtr++], OperatorStack [--OperatorStackPtr], sizeof (s_tag));
      }   
      
      //Ajoute signe dans la pile d'opérateurs
      OperatorStack [OperatorStackPtr++] = &StackTag [i];
    }
    
    //Ligne trop longue
    if (OperatorStackPtr==MAX_OPERATOR_STACK)
      {error_line = ERROR_LINETOOLONG; break;}
  }
  
  //Dépiler la pile d'opérateurs
  while (OperatorStackPtr--)
  {
    if (OperatorStack [OperatorStackPtr]->type==TAG_PARENTH0)
      {error_code = ERROR_SYNTAX; break;}
    
    memcpy (&TStackTag [TStackTagPtr++], OperatorStack [OperatorStackPtr], sizeof (s_tag));
  }
  
  
  /*char buffer[51] = {};
  
  for (int i=0; i<TStackTagPtr; i++)
    strncat (buffer, TStackTag [i].string.data, TStackTag [i].string.size);

  ClrScr ();
  printf_xy (0, 30, "%s", buffer);

  ngetchx ();*/
  
  
  StackTagPtr = 0; //Vide la pile
  if (error_code!=ERROR_NOERROR) return FALSE;
  return TRUE;
}