operations.c

Go to the documentation of this file.

#include"table.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"erreur.h"

static table_t t=NULL;
static int mem;
static int mem_pret=0;


static int recupereArgument(const char *arg, int *r);

static char* split (char* s, char c);

static int op_f(const char *arg, int *r, int(*op)(int,int));

static int print(const char *arg);

static int add_f(const char *arg, int *r);

static int mult_f(const char *arg, int *r);

static int sub_f(const char *arg, int *r);

static int quo_f(const char *arg, int *r);

static int mod_f(const char *arg, int *r);

/******************** Implementation *************************/
int recupereArgument(const char *arg, int *r){
  char *p;
  /*arg est-elle un nombre ?*/
  *r=(int)strtol(arg, &p, 0);
  if(*p=='\0')
    return 1;
  /*arg est-elle "$" ?*/
  if(strcmp(arg,"$")==0){
    if(!mem_pret){
      num_erreur=E_INIT;
      return 0;
    }
    *r=mem;
    return 1;
  }
  /*arg est-elle une variable stockee dans la table ?*/
  if(!t){
    num_erreur=E_INIT;
    return 0;
  }
  return find(t,arg,r);
}

char* split (char* s, char c){
  char* p=strchr(s,c);
  if(!p) return NULL;
  *p='\0';
  return p+1;
}

int op_f(const char *arg, int *r, int(*op)(int,int)){
  int x,y;
  char s[200];
  char *p;
  /*On copie arg dans une chaine modifiable */
  strcpy(s,arg);
  /*On separe les deux arguments: le premier commence en s, le second en p */
  p=split(s,' ');
  if(!p){
    num_erreur=E_SYNTAXE;
    return 0;
  }
  /*On recupere les valeurs et on applique l'operation */
  if( !recupereArgument(s, &x) || !recupereArgument(p, &y))
    return 0;
  mem=*r=op(x,y);
  mem_pret=1;
  return 1;
}

/* Cette macro permet de definir les fonctions
 *  add(), sub(), mult(), quo() et mod(), qui appliquent les operateurs +, -, *, / et % a leurs
 *  arguments entiers, ainsi que le code des fonctions add_f(), sub_f(), mult_f(), quo_f() et mod_f(),
 *  qui appellent op_f() avec la fonction ad hoc.
 */
#define DEFOP(NOM,OP)   \
static int NOM(int x, int y){  \
         return x OP y;        \
}                              \
                                   \
int NOM##_f(const char *arg, int *r){  \
  return op_f(arg,r,NOM);              \
}

/*On definit pour chaque operation ce qu'elle doit faire */
DEFOP(add,+)
DEFOP(sub,-)
DEFOP(mult,*)
DEFOP(quo,/)
DEFOP(mod,%)

#undef DEFOP

int print(const char *arg){
  int x;
  if( !recupereArgument(arg, &x)) return 0;
  printf("--> %d\n",x);
  return 1;
}

int traiteConstante(const char* ligne){
  char s[200];
  char *p;
  int x;
  /*On copie ligne dans une chaine modifiable */
  strcpy(s,ligne);
  /*On separe la variable et la valeur: la variable commence en s, la valeur en p */
  p=split(s,'=');
  if(!p){
    num_erreur=E_SYNTAXE;
    return 0;
  }
  /*On stocke la valeur dans x*/
  if(!recupereArgument(p,&x)){
    return 0;
  }
  /*On stocke la variable dans la table; au besoin on cree cette derniere*/
  if(!t)
    t=init_table();
  return add_symbole(t,s,x);
}

int traiteInstruction(const char* ligne){
  char s[200];
  char *p;
  static char* com[]=                    {"add", "sub", "mult", "div", "mod"};
  static int (*fct[])(const char*, int*)={add_f, sub_f, mult_f, quo_f, mod_f};
  int i;
  /*On copie ligne dans une chaine modifiable */
  strcpy(s,ligne);
  /*On separe l'operation des arguments: elle commence en s, ils commencent en p */
  p=split(s,' ');
  if(!p){
    num_erreur=E_SYNTAXE;
    return 0;
  }
  /*Selon la valeur de l'operation, on fait ce qu'il faut*/
  for(i=0;i<5;i++)
    if(strcmp(s,com[i])==0) return fct[i](p, &mem);
  if(strcmp(s,"print")==0) return print(p);
  /*Si on arrive ici, c'est que l'operation n'est pas licite*/
  num_erreur=E_UNSUP;
  return 0;
}

void end(){
  free_table(t);
  t=NULL;
  mem_pret=0;
}

---