######################################################################
                        GRAMMAIRE ATTRIBUEE
######################################################################

P = Program { D } E(te)
  "Crée une nouvelle portée la plus externe. Analyse les déclarations
  {D} et l'expression principale E dans cette portée."
   
D = ClassDef ident { F }({tf})
  "Crée dans la portée courante un symbole de classe de nom ident,
  avec un type de classe qui fait référence à une portée de champs S
  initialement vide. Traite les champs {F} en analysant leur type dans
  la portée courante et en les ajoutant dans la portée S."

  | FunDef ident { F }({tf}) T(tr) E(te)
  "Traite les paramètres {F} dans une portée imbriquée. Crée un
  symbole de fonction dans la portée courante ayant le nom ident et le
  type fonctionnel {tf} => tr."
  te <: tr

F(t) = Formal ident T(tf)
  "Crée un nouveau symbole de variable dans la portée courante avec le
  nom ident et le type tf."
  t = tf

T(t) = IntType                    t = Int
     | FunType { T }({tf}) T(tr)  t = type fonctionnel {tf} => tr
     | TypeIdent ident            t = type objet faisant référence au
                                      symbole lookup(ident) qui doit
                                      être un symbole de classe                                  

S = While E(te) { S }
    "Analyse la condition E dans la portée courante. Analyse les
    instructions {S} dans une portée imbriquée."
    te = Int

  | VarDef F(tf) E(te)
  "Analyse l'expression E dans la portée courante, puis analyse F dans
  la même portée."
  te <: tf

  | Assign ident E(te)
  sym = lookup(ident) est un symbole de variable
  te <: type de sym

  | Do E(te)

E(t) = If E(tc) E(t1) E(t2)     tc = Int, t = max(t1, t2)
     | Unop U E(te)             te = Int, t = Int
     | Binop IntOp E(t1) E(t2)  t1 = t2 = Int, t = Int
     | Binop EqOp E(t1) E(t2)   max(t1, t2) existe
                                t1 et t2 ne sont pas des types fonctionnels
                                t = Int
     | Ident ident              sym = lookup(ident) un symbole de variable
                                t = type of sym
     | NullLit                  t = Null
     | IntLit int               t = Int
     | Apply E(tf) { E }({ta})  tf = {tp} => tr, {ta} <: {tp}, t = tr 
     | Block { S } E(te)        "Analyse les instructions {S} et l'expression
                                principale E dans une portée imbriquée."
                                t = te
     | New ident { E }({ta})    cls = lookup(ident) un symbole de classe avec
                                un type de classe faisant référence à une portée
                                contenant des symboles de champs {sym}.
                                {ta} <: {sym.type}
                                t = type object faisant référence à cls
     | Select E(te) ident       te un type objet faisant référence à un symbole
                                de classe cls.
                                type de cls = type de classe faisant référence à
                                une portée S contenant des symboles de champs.
                                sym = lookup(ident) dans S
                                t = type de sym

U     = Not | Neg
B     = IntOp | EqOp
IntOp = Add | Sub | Mul | Div | Mod | Lt | Le | Gt | Ge | Or
EqOp  = Eq | Ne

######################################################################
$Id: attrib.txt,v 1.1 2004/12/10 14:54:00 cremet Exp $