Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 3 sur 3
  1. #1
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro Nicolas Vallée
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 209
    Détails du profil
    Informations personnelles :
    Nom : Homme Nicolas Vallée
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 209
    Points : 16 756
    Points
    16 756

    Par défaut peut-on cacher des attributs dans un type union ?

    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
    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

  2. #2
    LLB
    LLB est déconnecté
    Membre Expert
    Inscrit en
    mars 2002
    Messages
    962
    Détails du profil
    Informations forums :
    Inscription : mars 2002
    Messages : 962
    Points : 1 128
    Points
    1 128

    Par défaut

    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.

  3. #3
    Rédacteur/Modérateur

    Avatar de gorgonite
    Homme Profil pro Nicolas Vallée
    Ingénieur d'études
    Inscrit en
    décembre 2005
    Messages
    10 209
    Détails du profil
    Informations personnelles :
    Nom : Homme Nicolas Vallée
    Âge : 30
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur d'études
    Secteur : Transports

    Informations forums :
    Inscription : décembre 2005
    Messages : 10 209
    Points : 16 756
    Points
    16 756

    Par défaut

    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
    Evitez les MP pour les questions techniques... il y a des forums
    Contributions sur DVP : Mes Tutos | Mon Blog

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •