peut-on cacher des attributs dans un type union ? [Résolu]

[gorgonite]

Bonjour,


Je vais (enfin) passer aux choses sérieuses... la forme SSA

dans mon interprète très simpliste, j'ai décidé d'utiliser ce type pour mon ast

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/// represents the Abstract Syntax Tree
type struct_expr =
  |Intconst of int
  |Boolconst of bool
  |Test of string * struct_expr list
  |Operateur of string * struct_expr list
  |Var of string
  |Assign of struct_expr * struct_expr
  |If of struct_expr * struct_expr list * struct_expr list
  |While of struct_expr * struct_expr list
  |Break
  |Declare of string list
  |Assert of struct_expr
with
  member this.immediate_dominator : struct_expr option = None
  member this.domination_frontier : struct_expr list = []

ça me permet de jouer avec un match sur les éléments, mais j'aimerais aussi pouvoir avoir quelques petites infos cachées dont je vais avoir besoin pour le calcul de ma forme SSA à savoir :

• le dominateur immediat
• la frontière de domination

le hic est qu'actuellement je ne peux modifier ces propriétés...
comment feriez-vous sans trop changer la structure de l'ast ?


nb : je n'ai volontairement pas séparé les instructions des expressions
nb2 : je n'ai pas encore mis les phi et les attributs pour le renommage

[LLB]

Pour répondre au titre : non.

Il y a plusieurs solutions. Tu peux stocker ces informations supplémentaires dans une structure externe, par exemple une table de hachage. Ce n'est pas très fonctionnel, mais ça peut te convenir.

Tu peux aussi utiliser quelque chose comme :

Code F# :

1
2
3
4
5
6
type struct_expr = {
  data: struct_expr';
  immediate_dominator: struct_expr';
  domination_frontier: struct_expr' }
and struct_expr' =
  // ...

Le pattern matching reste toujours possible :

Code :

1
2
function
 | {data=IntConst 42} -> ...

Si c'est trop verbeux pour toi, tu peux toujours passer par des active patterns.

[gorgonite]

effectivement, je n'avais pas pensé aux active pattern


mais étant donné qu'il me faudra tout refaire, j'avais commencé par quelque chose de ce genre

Code :

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
type operateur =
  |Add |Sub |Mul |Div |Mod

type test_operateur =
  |Lt |Le |Gt |Ge |Eq |Ne |Neg

type variable = { name : string ; mutable indice : int option }

type expression =
  |Intconst of int
  |Boolconst of bool
  |Op of operateur * expression list
  |Test of test_operateur * expression list
  |Var of variable
  |Phi of expression list

type instruction = 
  |Entry |Exit
  |Assign of expression * expression
  |If of expression * struct_ast * struct_ast
  |While of expression * struct_ast
  |Break
  |Declare of variable list
  |Assert of expression
and ast_cell = 
  { instr : instruction ; mutable prev : ast_cell Set ; mutable next : ast_cell Set ; mutable iDom : struct_ast ; mutable domF : ast_cell Set  }
and struct_ast = ast_cell option

je regarderai plus tard comment tenter de tranposer en active patterns