Exercice 3

1.

Il affiche l'expression et son résultat.

2.

Fichier : LectForm.java

public class LectForm {
   char [] buflu ; // la chaine qui sera lue (ya pas de streams en Java !=)
  int indlu ;  // index parcourant la chaine lue

  public LectForm (String lu) {buflu = lu.toCharArray() ; indlu = 0;}

  ExpAr lpf () { // +le moteur r\'ecursif
      char carlu = buflu[indlu] ;
      indlu++ ;
      switch (carlu)
        {case '+' : 
           return new Add(lpf(), lpf());
         case '*' : 
           return new Mult (lpf(), lpf());
         case 'C' : 
           return new Acellule(lpf(),lpf());
         case '0': case '1': case '2': case '3': case '4':
         case '5': case '6': case '7': case '8': case '9':
           {System.out.println("..."+carlu);
            return new Cte((int) carlu - (int) '0') ;}
        /* sinon c'est une constante */
         default : {System.out.println(",,,"+carlu);
                    return new Cte((int) carlu - (int) '0') ;}
         }
       }
}

/* Le code Java present\'e en cours le 21-11-96 :
  modifi\'e le 28/11 pour renvoyer la cha\^{\i}ne de caract\`eres
  de la notation cp et non pour l'imprimer sur le fichier de sortie
 */



abstract class ExpAr { // classe abstraite racine de l'arbre d'heritage
    abstract int eval () ;
    abstract int eval (Env e) ;
    abstract String scp () ;
}

class Cte extends ExpAr { // premiere sous-classe concrete
    int val ;

    Cte (int v) {val = v ;}
    int eval () { return val ;}
    int eval (Env e) { return eval();}
    String scp () {return (new Integer(val)).toString() ;}
}

abstract class Bin extends ExpAr {
    ExpAr og, od ;
    abstract int oper (int g , int d) ;
    abstract String cop () ;

    int eval (Env e) {return oper (og.eval(e), od.eval(e)) ;}
    int eval () {return oper (og.eval(), od.eval()) ;}
    String scp () {return ("("+ og.scp() + cop() + od.scp() +")") ; }
    void init (ExpAr g, ExpAr d) {og = g ;od =  d ;}
}

class Add extends Bin {
    Add (ExpAr g, ExpAr d) {init (g, d) ;}
    int oper (int g, int d) {return (g+d) ;}
    String cop () {return ("+") ;}
}

class Mult extends Bin {
    Mult (ExpAr g, ExpAr d) {init (g, d) ;}
    int oper (int g, int d) {return (g*d) ;}
    String cop () {return ("*") ;}
}


class Env {

  public int width;
  public int height;
  public ExpAr [][] env;

  public Env(int w, int h) {
    width=w; height=h;
    env = new ExpAr [width][height];
  }

 }


class Acellule extends ExpAr {
  int x;
  int y;

  Acellule(){x=0;y=0;}
  Acellule(ExpAr a, ExpAr b) {x=a.eval(); y=b.eval();System.out.println("___"+x+"___"+y);}

  int eval(Env e){ return e.env[x][y].eval(e);}
  int eval(){return 0;}
  String scp(){ return ("(C"+x+"#"+y+")");}
  
}

3.

l'exemple précédent répond aux 2 questions.

4.

il faut définir de nouvelles sous-classes étendant les classes concretes des expressions, pour détecter en retournant un booléen : boolean cycle(). On ajoute un champs booleen (ou on définit une sous-classe) des Acellule, permettant de marquer son passage, si quand on rencontre une Acellule ce flag est vrai, alors il y a un cycle, sinon on itere le processus à l'expression rencontrée. Il faut aussi ajouter cette methode aux constantes, et operateurs binaires. Il faut aussi penser à remettre ce flag à false une fois la détection finie.

5.

on laisse les adresses relatives en exercice.

6.

Fichier : Essai3.java

import java.awt.* ;

public class Essai3 extends java.applet.Applet {

// la taille
   int nl=4;
   int nc=3;
    
   String field = "";

// env pour l'env global
// dispGlob pour les champs de saisie
// labGlob pourles champs de sortie

   Env  envGlob;
   TextField  [][]dispGlob;
//   String [][]outGlob;
   Label [][]labGlob;
   
 
   TextField ligne = new TextField ("Votre expression") ;
   String res = "Debut" ;

   public void init () {
     dispGlob= new TextField[nc][nl];
     envGlob=new Env(nc,nl);
//     outGlob=new String[nc][nl];
     labGlob=new Label[nc][nl];
     for (int i=0;i<nc;i++)  {
       for (int j=0;j<nl;j++) {
//         outGlob[i][j]= ".";
         labGlob[i][j]=new Label(field); //outGlob[i][j]);
         dispGlob[i][j]=new TextField(" "); //outGlob[i][j],2);
         envGlob.env[i][j]= new Cte(0);
       }
     }
     setLayout (new GridLayout(nl,nc*2));
     for (int j=0;j<nl;j++) {
        for (int i=0;i<nc;i++) {
           add(dispGlob[i][j]);
        }
        for (int i=0;i<nc;i++) {
           add(labGlob[i][j]);
        }
     }

   }

   public boolean action (Event e, Object arg) {
      for (int j=0;j<nl;j++) {
        for (int i=0;i<nc;i++) {
          if (e.target == dispGlob[i][j])
            {agir ((String) arg,i,j) ; return true ; }
          }
        }
     return false ;
     }

   void agir (String lu,int i, int j) { int res;
     LectForm lec = new LectForm (lu) ;
     System.out.println("-->"+lu);
     envGlob.env[i][j]= lec.lpf() ;
     System.out.println(envGlob.env[i][j].scp());
     res= envGlob.env[i][j].eval(envGlob);
//     outGlob[i][j]= " "+res+" ";
     System.out.println("["+i+","+j+"] = "+res);
     
     labGlob[i][j].setText(""+res+"");
     repaint();
     }

}