Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
(*----------------------------------------------------------------------
module : EvalConst
date :
------------------------------------------------------------------------
DESCRIPTION :
Evaluation statique des expressions "réputées" constantes
(defs de constantes, tailles de tableaux, indices et step des arrays).
PARAMETRES :
Pour avoir qq chose de générique, les fonctions
sont paramétrées par un "id_solver", qui contient deux fonctions :
(voir CompileData)
type id_solver = {
id2const : Syntaxe.idref -> Lxm.t -> const_eff
id2type : Syntaxe.idref -> Lxm.t -> const_eff
}
(N.B. on passe le lexeme pour déventuels messages d'erreurs)
FONCTION PRINCIPALE :
Elle lève "Compile_error lxm msg" en cas d'erreur.
eval_const
(env : id_solver)
(vexp : val_exp)
-> const_eff list
(N.B. dans le cas général, une val_exp peut dénoter un tuple, on
rend donc bien une liste de constante)
FONCTIONS DERIVEES : (permet de préciser les messages d'erreur)
Elles lèvent "EvalArray_error msg" en cas d'erreur,
se qui permet de récupérer l'erreur.
eval_array_size
(env : id_solver)
(vexp : val_exp)
-> int
(N.B. ne renvoie que des taille correctes : > 0)
eval_array_index
(env : id_solver)
(vexp : val_exp)
(sz : int)
-> int
(N.B. on doit préciser la taille sz du tableau)
eval_array_slice
(env : id_solver)
(sl : slice_info srcflaged)
(sz : int)
(lxm : Lexeme.t)
-> slice_eff
N.B. slice_eff = {first: int; last: int; step: int; width: int}
N.B. on doit passer le lexeme de l'opération à cause d'éventuels
warnings
----------------------------------------------------------------------*)
open CompileData
exception EvalArray_error of string
(*----------------------------------------------------
eval_const
----------------------------------------------------*)
val eval_const : id_solver -> Syntaxe.val_exp -> const_eff list
(*---------------------------------------------------------------------
eval_array_size
-----------------------------------------------------------------------
Rôle : calcule une taille de tableau
Entrées:
Sorties :
int (strictement positif)
Effets de bord :
EvalArray_error "bad array size, type int expected but get <t>" si t pas int
EvalArray_error "bad array size <n>" si n <= 0
----------------------------------------------------------------------*)
val eval_array_size : id_solver -> Syntaxe.val_exp -> int
(*---------------------------------------------------------------------
eval_array_index
-----------------------------------------------------------------------
Rôle :
Entrées :
id_solver, val_exp, taille du tableau
Sorties :
int (entre 0 et taille du tableau -1
Effets de bord :
EvalArray_error msg si pas bon
----------------------------------------------------------------------*)
val eval_array_index : id_solver -> Syntaxe.val_exp -> int -> int
(*---------------------------------------------------------------------
eval_array_slice
-----------------------------------------------------------------------
Rôle :
Entrées :
id_solver, slice_info, size du tableau,
lxm (source de l'opération slice pour warning)
Sorties :
slice_eff, i.e.
(fisrt,last,step,width) tels que step <> 0 et
- si step > 0 alors 0<=first<=last et first<=sz
- si step < 0 alors 0<=last<=first et first<=sz
- 1<=width<=sz
Effets de bord :
EvalArray_error msg si pas bon
----------------------------------------------------------------------*)
val eval_array_slice : id_solver -> Syntaxe.slice_info -> int -> Lxm.t -> slice_eff