Coverage Report - ProjetCompil.Verif.Src.ReglesTypage
 
Classes in this File Line Coverage Branch Coverage Complexity
ReglesTypage
56 %
60/107
33 %
35/103
19,333
ReglesTypage$1
0 %
0/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  75
 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  45
            ResultatAffectCompatible result = new ResultatAffectCompatible();
 19  
 
 20  0
                 switch (t1.getNature()) {
 21  
                         case Interval:
 22  25
                                 if (t2.getNature() == NatureType.Interval)
 23  20
                                         result.setOk(true);
 24  
                                 else
 25  5
                                         result.setOk(false);
 26  5
                                 break;
 27  
 
 28  
                         case Boolean:
 29  17
                                 if (t2.getNature() == NatureType.Boolean)
 30  14
                                         result.setOk(true);
 31  
                                 else
 32  3
                                         result.setOk(false);
 33  3
                                 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  3
                                 if (t2.getNature() == NatureType.Real)
 43  0
                                         result.setOk(true);
 44  3
                                 else if (t2.getNature() == NatureType.Interval) {
 45  3
                                         result.setConv2(true); // On convertis l'interval en Real
 46  3
                                         result.setOk(true);
 47  3
                                 }
 48  
                                 else 
 49  0
                                         result.setOk(false);
 50  0
                                 break;
 51  
 
 52  
                         case Array:
 53  0
                                 if (t2.getNature() == NatureType.Array
 54  0
                                                 && t1.getIndice().getBorneInf() == t2.getIndice().getBorneInf()
 55  0
                                                 && t1.getIndice().getBorneSup() == t2.getIndice().getBorneSup()) {
 56  0
                                         result = affectCompatible(t1.getElement(), t2.getElement()); // Recursif car on peux faire des tableaux multi-dimensionnels
 57  0
                                 }
 58  
                                 else
 59  0
                                         result.setOk(false);
 60  0
                                 break;
 61  
 
 62  
                         default:
 63  0
                                 throw new ErreurReglesTypage();
 64  
                 }
 65  45
                 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  18
            ResultatBinaireCompatible result = new ResultatBinaireCompatible();
 75  
 
 76  0
                 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  1
                                 }
 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  4
                                 switch(t1.getNature()){
 93  
                                         case Interval:
 94  
                                         case Real:
 95  2
                                                 if (t2.getNature() == NatureType.Interval || t2.getNature() == NatureType.Real){
 96  2
                                                         result.setOk(true);
 97  2
                                                         result.setTypeRes(Type.Boolean);
 98  2
                                                 }
 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  14
                                 switch (t1.getNature()) {
 111  
                                         case Interval:
 112  5
                                                 if (t2.getNature() == NatureType.Interval){
 113  5
                                                         result.setOk(true);
 114  5
                                                         result.setTypeRes(Type.Integer);
 115  5
                                                 }
 116  0
                                                 else if (t2.getNature() == NatureType.Real){
 117  0
                                                         result.setOk(true);
 118  0
                                                         result.setTypeRes(Type.Real);
 119  0
                                                 }
 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  0
                                                 }
 129  
                                                 else
 130  0
                                                         result.setOk(false);
 131  0
                                         break;
 132  
                                         
 133  
                                         default:
 134  2
                                                 result.setOk(false);
 135  
                                 }
 136  2
                         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  1
                                 }
 143  
                                 else
 144  0
                                         result.setOk(false);
 145  0
                         break;
 146  
                         case DivReel:
 147  2
                                 switch(t1.getNature()){
 148  
                                         case Interval:
 149  
                                         case Real:
 150  1
                                                 if (t2.getNature() == NatureType.Interval || t2.getNature() == NatureType.Real){
 151  1
                                                         result.setOk(true);
 152  1
                                                         result.setTypeRes(Type.Real);
 153  1
                                                 }
 154  
                                                 else{
 155  0
                                                         result.setOk(false);
 156  
                                                 }
 157  0
                                         break;
 158  
                                         
 159  
                                         default:
 160  0
                                                 result.setOk(false);
 161  
                                         break;
 162  
                                 }
 163  0
                         break;
 164  
                         case Index:
 165  6
                                 if (t1.getNature() == NatureType.Array        && t2.getNature() == NatureType.Interval) {
 166  6
                                         result.setOk(true);
 167  6
                                         result.setTypeRes(t1.getElement());
 168  6
                                 }
 169  
                                 else
 170  0
                                         result.setOk(false);
 171  0
                         break;
 172  
                         
 173  
                         default:
 174  0
                                 throw new ErreurReglesTypage();
 175  
                 }
 176  
                 
 177  18
                 return result;
 178  
    }
 179  
 
 180  
    /**
 181  
     * Teste si le type t est compatible pour l'opération binaire représentée 
 182  
     * dans noeud.
 183  
     */
 184  
    static ResultatUnaireCompatible unaireCompatible(Noeud noeud, Type t) throws ErreurReglesTypage {
 185  2
            ResultatUnaireCompatible result = new ResultatUnaireCompatible();
 186  4
            switch (noeud){
 187  
                            case Non:
 188  1
                                    if (t.getNature() == NatureType.Boolean){
 189  1
                                            result.setOk(true);
 190  1
                                         result.setTypeRes(Type.Boolean);
 191  1
                                    }
 192  
                                    else
 193  0
                                            result.setOk(false);
 194  0
                            break;
 195  
                            case PlusUnaire:
 196  
                            case MoinsUnaire:
 197  1
                                    if (t.getNature() == NatureType.Interval){
 198  0
                                            result.setOk(true);
 199  0
                                         result.setTypeRes(Type.Integer);
 200  0
                                    }
 201  1
                                    else if (t.getNature() == NatureType.Real){
 202  0
                                            result.setOk(true);
 203  0
                                         result.setTypeRes(Type.Real);
 204  0
                                    }
 205  
                                    else
 206  1
                                            result.setOk(false);
 207  1
                                    break;
 208  
                       default:
 209  0
                               throw new ErreurReglesTypage();
 210  
       }
 211  
            
 212  2
            return result;
 213  
       
 214  
    }
 215  
          
 216  
 }
 217