%{

/* texte C global */
#include <stdio.h>
#include <math.h>

#define STACKMAX 20

double stack[STACKMAX];
int    stacklen=0;

void display_help(void);
void stack_in(double n);
double stack_out(void);
double stack_get(int n);
int stack_len(void);
void stack_list(void);
void stack_print(void);
void stack_dup(void);
void stack_swap(void);
void stack_pop(void);
void stack_clear(void);
void stack_int(void);
void stack_add(void);
void stack_sub(void);
void stack_mul(void);
void stack_div(void);
void stack_mod(void);
int stack_isint(int n);

%}

	/* texte C global */
	int ncomment = 0;
	int nligne = 0;

/* Definitions lex */

%%
	/* Regles lex */

-?[0-9]+(\.)?[0-9]*	{ stack_in(atof(yytext)); }
"help"			{ display_help(); }
"quit"			{ exit(0); }
"print"			{ stack_print(); }
"list"			{ stack_list(); }
"dup"			{ stack_dup(); }
"change"		{ stack_swap(); }
"pop"			{ stack_pop(); }
"clear"			{ stack_clear(); }
"int"			{ stack_int(); }
"+"			{ stack_add(); }
"-"			{ stack_sub(); }
"*"			{ stack_mul(); }
"/"			{ stack_div(); }
"%"			{ stack_mod(); }
.			;
"\n"			;

%%
/* Fonctions C */


int yywrap()
{
  return 1;
}

void display_help()
{
  printf("Nombre entiers ou reels\n");
  printf("Operations: + - / * %\n");
  printf("Commandes:  print dup change pop int help list clear quit\n");
}

void stack_in(double n)
{
  stack[stacklen] = n;
  stacklen += 1;
}

double stack_out()
{
  double dum = stack_get(stack_len()-1);
  stacklen -= 1;
  return dum;
}

double stack_get(int n)
{
  if (n < stacklen)
    return stack[n];
}

int stack_len()
{
  return stacklen;
}

void stack_list()
{
  int i;

  if (stack_len() > 0)
  {
    for (i=0; i<stack_len(); i++)
      printf("%20.8f\n", stack_get(stack_len()-i-1));
  }
  else
    printf("Pile vide!\n");
}

void stack_print()
{
  if (stack_len() > 0)
    printf("%20.8f\n", stack_get(stack_len()-1));
  else
    printf("Pile vide!\n");
}

void stack_dup()
{
  if (stack_len() > 0)
  {
    stack_in(stack_get(stack_len()-1));
  }
  else
    printf("Pile vide!\n");
}

void stack_swap()
{
  double n1, n2;

  if (stack_len() > 1)
  {
    n1 = stack_out();
    n2 = stack_out();
    stack_in(n1);
    stack_in(n2);
  }
  else
    printf("Pas assez d'elements dans la pile!\n");
}

void stack_pop()
{
  if (stack_len() > 0)
  {
    printf("%20.8f\n", stack_out());
  }
  else
    printf("Pile vide!\n");
}

void stack_clear()
{
  stacklen = 0;
}

void stack_int()
{
  double n;

  if (stack_len() > 0)
  {
    n = stack_out();
printf("%f %f\n", n, floor(n));
    stack_in(floor(n));
  }
  else
    printf("Pile vide!\n");
}

void stack_add()
{
  double n1, n2;

  if (stack_len() > 1)
  {
    n2 = stack_out();
    n1 = stack_out();
    stack_in(n1+n2);
  }
  else
    printf("Pas assez d'elements dans la pile!\n");
}

void stack_sub()
{
  double n1, n2;
  
  if (stack_len() > 1)
  { 
    n2 = stack_out();
    n1 = stack_out();
    stack_in(n1-n2);
  }
  else
    printf("Pas assez d'elements dans la pile!\n");
}

void stack_mul()
{
  double n1, n2;
  
  if (stack_len() > 1)
  { 
    n2 = stack_out();
    n1 = stack_out();
    stack_in(n1*n2);
  }
  else
    printf("Pas assez d'elements dans la pile!\n");
}

void stack_div()
{
  double n1, n2;
  
  if (stack_len() > 1)
  {
    if (stack_get(stack_len()-1) != 0)
    { 
      n2 = stack_out();
      n1 = stack_out();
      stack_in(n1/n2);
    }
    else
      printf("Division par 0!\n");
  }
  else
    printf("Pas assez d'elements dans la pile!\n");
}

void stack_mod()
{
  int n1;
  int n2;
  
  if (stack_len() > 1)
  { 
    if (stack_get(stack_len()-1) != 0)
    {
      if (stack_isint(stack_len()-1) && stack_isint(stack_len()-2))
      {
        n2 = (int)floor(stack_out());
        n1 = (int)floor(stack_out());
        stack_in(n1%n2);
      }
      else
        printf("Modulo non entier!\n");
    }
    else
      printf("Division par 0!\n");
  }
  else
    printf("Pas assez d'elements dans la pile!\n");
}

int stack_isint(n)
{
  if (stack_get(n) == floor(stack_get(n)))
    return 1;
  return 0;
}