Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
ReglesTypage |
|
| 19.333333333333332;19,333 | ||||
ReglesTypage$1 |
|
| 19.333333333333332;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 |