Coverage Report - ProjetCompil.Verif.Src.ReglesTypage
 
Classes in this File Line Coverage Branch Coverage Complexity
ReglesTypage
39 %
36/92
28 %
23/82
19,333
ReglesTypage$1
100 %
2/2
N/A
19,333
 
 1  
 package ProjetCompil.Verif.Src;
 2  
 
 3  
 import ProjetCompil.Global.Src.*;
 4  
 
 5  
 /**
 6  
  * La classe ReglesTypage permet de définir les différentes règles 
 7  
  * de typage du langage JCas.
 8  
  */
 9  
 
 10  0
 public class ReglesTypage {
 11  
 
 12  
    /**
 13  
     * Teste si le type t1 et le type t2 sont compatibles pour l'affectation, 
 14  
     * c'est à dire si on peut affecter un objet de t2 à un objet de type t1.
 15  
     */
 16  
 
 17  
    static ResultatAffectCompatible affectCompatible(Type t1, Type t2) throws ErreurReglesTypage {
 18  12
            ResultatAffectCompatible result = new ResultatAffectCompatible();
 19  
 
 20  4
                 switch (t1.getNature()) {
 21  
                         case Interval:
 22  8
                                 if (t2.getNature() == NatureType.Interval)
 23  8
                                         result.setOk(true);
 24  
                                 else
 25  0
                                         result.setOk(false);
 26  0
                                 break;
 27  
 
 28  
                         case Boolean:
 29  3
                                 if (t2.getNature() == NatureType.Boolean)
 30  3
                                         result.setOk(true);
 31  
                                 else
 32  0
                                         result.setOk(false);
 33  0
                                 break;
 34  
 
 35  
                         /*case Integer:
 36  
                                 if (t2.getNature() == NatureType.Integer)
 37  
                                         result.setOk(true);
 38  
                                 else
 39  
                                         result.setOk(false);*/
 40  
                         
 41  
                         case Real:
 42  0
                                 if (t2.getNature() == NatureType.Real)
 43  0
                                         result.setOk(true);
 44  0
                                 else if (t2.getNature() == NatureType.Interval) {
 45  0
                                         result.setConv2(true); // On convertis l'interval en Real
 46  0
                                         result.setOk(true);
 47  
                                 }
 48  
                                 else 
 49  0
                                         result.setOk(false);
 50  0
                                 break;
 51  
 
 52  
                         case Array:
 53  1
                                 if (t2.getNature() == NatureType.Array
 54  
                                                 && t1.getIndice().getBorneInf() == t2.getIndice().getBorneInf()
 55  
                                                 && t1.getIndice().getBorneSup() == t2.getIndice().getBorneSup()) {
 56  0
                                         result = affectCompatible(t1.getElement(), t2.getElement()); // Recursif car on peux faire des tableaux multi-dimensionnels
 57  
                                 }
 58  
                                 else
 59  1
                                         result.setOk(false);
 60  1
                                 break;
 61  
 
 62  
                         default:
 63  0
                                 throw new ErreurReglesTypage();
 64  
                 }
 65  12
                 return result;
 66  
    }
 67  
 
 68  
    /**
 69  
     * Teste si le type t1 et le type t2 sont compatible pour l'opération 
 70  
     * binaire représentée dans noeud.
 71  
     */
 72  
 
 73  
    static ResultatBinaireCompatible binaireCompatible(Noeud noeud, Type t1, Type t2) throws ErreurReglesTypage {
 74  16
            ResultatBinaireCompatible result = new ResultatBinaireCompatible();
 75  
 
 76  4
                 switch (noeud) {
 77  
                         case Et:
 78  
                         case Ou:
 79  1
                                 if (t1.getNature() == t2.getNature() && t1.getNature() == NatureType.Boolean){
 80  1
                                         result.setOk(true);
 81  1
                                         result.setTypeRes(Type.Boolean);
 82  
                                 }
 83  
                                 else
 84  0
                                         result.setOk(false);
 85  0
                         break;
 86  
                         case Egal:
 87  
                         case Inf:
 88  
                         case Sup:
 89  
                         case InfEgal:
 90  
                         case SupEgal:
 91  
                         case NonEgal:
 92  3
                                 switch(t1.getNature()){
 93  
                                         case Interval:
 94  
                                         case Real:
 95  3
                                                 if (t2.getNature() == NatureType.Interval || t2.getNature() == NatureType.Real){
 96  3
                                                         result.setOk(true);
 97  3
                                                         result.setTypeRes(Type.Boolean);
 98  
                                                 }
 99  
                                                 else
 100  0
                                                         result.setOk(false);
 101  0
                                         break;
 102  
                                         
 103  
                                         default:
 104  0
                                                 result.setOk(false);
 105  
                                 }
 106  0
                         break;
 107  
                         case Plus:
 108  
                         case Moins:
 109  
                         case Mult:
 110  4
                                 switch (t1.getNature()) {
 111  
                                         case Interval:
 112  4
                                                 if (t2.getNature() == NatureType.Interval){
 113  4
                                                         result.setOk(true);
 114  4
                                                         result.setTypeRes(Type.Integer);
 115  
                                                 }
 116  0
                                                 else if (t2.getNature() == NatureType.Real){
 117  0
                                                         result.setOk(true);
 118  0
                                                         result.setTypeRes(Type.Real);
 119  
                                                 }
 120  
                                                 else{
 121  0
                                                         result.setOk(false);
 122  
                                                 }
 123  0
                                         break;
 124  
                                         case Real:
 125  0
                                                 if (t2.getNature() == NatureType.Interval || t2.getNature() == NatureType.Real){
 126  0
                                                         result.setOk(true);
 127  0
                                                         result.setTypeRes(Type.Real);
 128  
                                                 }
 129  
                                                 else
 130  0
                                                         result.setOk(false);
 131  0
                                         break;
 132  
                                         
 133  
                                         default:
 134  0
                                                 result.setOk(false);
 135  
                                 }
 136  0
                         break;
 137  
                         case Quotient:
 138  
                         case Reste:
 139  1
                                 if (t1.getNature() == t2.getNature() && t1.getNature() == NatureType.Interval){
 140  1
                                         result.setOk(true);
 141  1
                                         result.setTypeRes(Type.Integer);
 142  
                                 }
 143  
                                 else
 144  0
                                         result.setOk(false);
 145  0
                         break;
 146  
                         case DivReel:
 147  0
                                 switch(t1.getNature()){
 148  
                                         case Interval:
 149  
                                         case Real:
 150  0
                                                 if (t2.getNature() == NatureType.Interval || t2.getNature() == NatureType.Real){
 151  0
                                                         result.setOk(true);
 152  0
                                                         result.setTypeRes(Type.Real);
 153  
                                                 }
 154  
                                                 else{
 155  0
                                                         result.setOk(false);
 156  
                                                 }
 157  0
                                         break;
 158  
                                         
 159  
                                         default:
 160  0
                                                 result.setOk(false);
 161  0
                                         break;
 162  
                                 }
 163  
                         break;
 164  
                         case Index:
 165  
                                 /*System.out.println("t1 :" + t1.toString());
 166  
                                 System.out.println("t2 :" + t2.toString());*/
 167  7
                                 if (t1.getNature() == NatureType.Array        && t2.getNature() == NatureType.Interval) {
 168  
                                         //System.out.println("Resultat : " + t1.getElement());
 169  
                                         
 170  7
                                         result.setOk(true);
 171  7
                                         result.setTypeRes(t1.getElement());
 172  
                                 }
 173  
                                 else
 174  0
                                         result.setOk(false);
 175  0
                         break;
 176  
                         
 177  
                         default:
 178  0
                                 throw new ErreurReglesTypage();
 179  
                 }
 180  
                 
 181  16
                 return result;
 182  
    }
 183  
 
 184  
    /**
 185  
     * Teste si le type t est compatible pour l'opération binaire représentée 
 186  
     * dans noeud.
 187  
     */
 188  
    static ResultatUnaireCompatible unaireCompatible(Noeud noeud, Type t) throws ErreurReglesTypage {
 189  1
            ResultatUnaireCompatible result = new ResultatUnaireCompatible();
 190  1
            switch (noeud){
 191  
                            case Non:
 192  1
                                    if (t.getNature() == NatureType.Boolean){
 193  1
                                            result.setOk(true);
 194  1
                                         result.setTypeRes(Type.Boolean);
 195  
                                    }
 196  
                                    else
 197  0
                                            result.setOk(false);
 198  0
                            break;
 199  
                            case PlusUnaire:
 200  
                            case MoinsUnaire:
 201  0
                                    if (t.getNature() == NatureType.Interval){
 202  0
                                            result.setOk(true);
 203  0
                                         result.setTypeRes(Type.Integer);
 204  
                                    }
 205  0
                                    else if (t.getNature() == NatureType.Real){
 206  0
                                            result.setOk(true);
 207  0
                                         result.setTypeRes(Type.Real);
 208  
                                    }
 209  
                                    else
 210  0
                                            result.setOk(false);
 211  0
                                    break;
 212  
                       default:
 213  0
                               throw new ErreurReglesTypage();
 214  
       }
 215  
            
 216  1
            return result;
 217  
       
 218  
    }
 219  
          
 220  
 }
 221