Le but du devoir est de créer le tableau de symboles et d'écrire l'analyse sémantique pour le langage Alf.

Vous recevrez un AST de l'analyseur qui analyse correctement une source de langue Alf et doit écrire:

1. le tableau des symboles
2. un nouvel AST avec les modifications suivantes
   1. le nouvel AST est une liste de statements des fonctions
   2. tous les noeuds de l'AST auront une propriété appellée symbol_table qui fera référence a l'entrée du tableau de symboles ou ils déclarent des variables, fonctions et types
   3. le programme principal s'appelle “script”
      1. tous les autres définitions des fonctions seront transférées de l'ancien AST vers le nouvel AST
      2. toutes les noeuds de définition des variables sont supprimés ou, s'ils ont une attribution @var i:int ← 3;, seront remplacés par un noeud d'attribution i ← 3;
3. la list des erreurs

Le programme recevra deux paramètres de la ligne de commande:

• le fichier source
• le fichier de sortie

noeud main.js source.alf source.alf.json

Vous pouvez utiliser votre fichier de grammaire ou le fichier reference

• Faire le tableau des symboles
• Déterminer tous les types de variables dans le tableau des symboles
• Déterminer les types pour toutes les instructions qui retournent un résultat
• Lors de la détermination des types, écrivez les erreurs

Le format du fichier de sortie est le suivant

{
    symbol_table: [...], // le tableau symbol_table
    ast: [...], // l'ast avec le type pour un noeud qui retourne une valeur
    error_list: [] // la liste des erreurs
}

Le tableau des symboles est un objet Javascript, ou chaque propriété est le nom d'un contexte. Dans l'exemple ci-dessous, on peut voir qu'il y a 2 contextes:

• script - le contecte du script principal
• function_sum - le contexte généré par la fonction sum

{
   "script": {
      "type": "script",
      "variables": {},
      "functions": {
         "sum": {
            "type": "int",
            "parameters": [
               { 
                  "type": "int",
                  "title": "n1",
                  "line": 4
               },
               { 
                  "type": "int",
                  "title": "n2",
                  "line": 4
               }
             ],
             "line": 4
          }
       },
       "types": {}
    },
    "function_sum": {
       "title": "sum",
       "type": "function",
       "parent": "script",
       "variables": {
          "n1": {
              "type": "int",
              "parameter": true,
              "index": 0
          },
          "n2": {
             "type": "int",
             "parameter": true,
             "index": 1
          }
       },
       "functions": {},
       "types": {}
    }
}

Lors de la détermination de la table de symboles, ajoutez à chaque noeud AST un paramètre symbole_table avec le nom du tableau de symboles ou il a les variables, fonctions et types.

Les objets de contexte stockent

• la variable déclarée dans ce contexte
• la fonction déclarée dans ce contexte
• les types (array, struct) déclarés dans ce contexte
• l'identifiant de contexte parent (position dans le tableau symbol_table)
• le nom du contexte
• le type du contexte (script, statements ou function)
• le nom de la fonction, si le contexte est de type 'function'

L'objet ressemble à:

{
   "variables": {// un dictionnaire des variables
      "variable_name": {
         "type": // type de la variable
         "line": // la ligne où la variable a été déclarée
         "value": // l'expression que la variable a initialement (facultatif, si elle a ete definie avec une valeur)
      }
   },
   "functions": {// un dictionnaire des fonctions
      function_title": {
         "type": // le type de retour de la fonction
         "parameters": [] // la liste des paramètres que la fonction prenne (le noeud parameters de l'AST)
         "line": // la ligne où la fonction a été déclarée
 
      }
   },
   "types": {// un dictionnaire de types
      "type": {
               "type": // le type de la nouvelle classe de type ou tableau
               "line": // la ligne où le type a été déclaré
               // pour le tableau
               "elements_type": // le type de chaque élément du tableau
               "first": // le premier index
               "length": // numero d'elements
               // pour la classe
               "properties": [// une liste d'éléments de tableau (le noeud de l'AST)
                  {
                     "type":
                     "title":
                     "value":
                     "line":
                     "symbol_table":
                  },
                  ...
               ]
            }
   },
   "parent": 
   "type": //
 
}

1. script - script
2. function - titre de la fonction
3. if_then
4. loop_when
5. loop_go

L'AST donné par le parser doit etre transformé afin de ne plus contenir de variables, fonctions ou définitions de types.

Le nouvel AST sera une liste d'objets, chaque objet étant soit le script, soit une fonction.

[
   "script": {
      statements: [
         ...
      ]
   },
   "function_title": {
      statements: [
         ...
      ]
   }
]

Les définitions des variables seront écrites dans le tableau de symboles. La définition sera supprimée de l'AST (elle ne sera pas placée dans les statements). Si la définition inclut une attribution @var x: int ← 7;, elle sera remplacée par un noeud d'attribution equivalent a x ← 7;.

Les structures et les vecteurs sont des définitions des types. Ils seront écrits dans la partie types du tableau de symboles.

Pour struct, si les propriétés ont des valeurs par défaut, chaque déclaration de variable de la structure sera remplacée par des attribution pour toutes les propriétés. Il y a un example dans le repository.

Pour chacun des noeuds suivants, déterminez le type de retour

• expr
• value
• identifier
• return
• element_of_vector
• property
• function

Définissez le type en ajoutant une propriété type dans le noeud. Tous les autres éléments ont le type de retour none. S'il y a une erreur de types, le type sera error.

{   
   "id": "expr",
   "op": "+",
   "left": {
         "id": "value",
         "type": "int",
         "value": "2",
         "line": 3,
         "symbol_table": "script",  
   },
   "right": {
         "id": "value",
         "type": "int",
         "value": 3,
         "line": 3,
         "symbol_table": "script"
   },
   "line": 3,
   "symbol_table": script,
   "type": "int"
}

Pour tous les noeuds AST, vérifiez que les types correspondent:

• attributions sont faisables
• les expressions peuvent être calculées
• l'expression if / while / repeat a une valeur logique
• la variable est un nombre / string / boolean
• que les variables sont définies avant d'être utilisées
• les fonctions sont définies avant d'être utilisées
• les index de tableau sont des nombres
• les propriétés de la classe existent
• la variable pour element_of_array est un tableau
• la variable pour une propriété est une classe
• les variables ne sont pas redéfinies
• les fonctions ne sont pas redéfinies
• les types ne sont pas redéfinis

La liste d'erreurs est un tableau qui contient des objets d'erreur. L'ordre dans lequel ces erreurs figurent dans la liste vous appartient.

Chaque erreur a le format suivant:

{
    type: // chaîne avec le type d'erreur
    elements: {
       // éléments pour l'erreur, chaque type d'erreur a des éléments différents
       line:
    },
    text: // le message d'erreur
}

Le type d'erreur est une chaîne avec l'un des titres suivants

L'erreur se produit lorsqu'une définition de variable est répétée.

{
    variable: // nom de la variable
}

L'erreur se produit lorsqu'une définition de fonction est répétée.

{
    function: // nom de la fonction
}

L'erreur se produit lors de la répétition d'une définition de type (tableau ou struct).

{
    type: // nom du type
}

L'erreur se produit lorsqu'une définition d'élément struct est répétée.

{
    type: // nom du type de structure
    title: // nom de l'élément
}

L'erreur se produit lorsque l'index inférieur du tableau est supérieur à l'index supérieur

{
    array: // nom du type de tableau
    length: 
}

L'erreur se produit lorsque le type d'une variable n'est pas déterminable (bonus uniquement).

// variable
{
    variable: // le nom de la variable avec le type non résolu
}
// struct property
{
    struct: // nom du type de structure
    property: // nom de l'élément struct avec le type non résolu
}

L'erreur se produit lorsqu'un appel de fonction est effectué sur une fonction qui n'est pas définie.

{
   title: // nom du message
}

L'erreur se produit lorsqu'une variable non définie est utilisée.

{
   variable: // nom de la variable
}

L'erreur se produit lorsqu'un type qui n'est pas défini est utilisé.

{     value: le type qui n'est pas definit } === NOT_STRUCT_PROPERTY === L'erreur se produit lorsqu'un élément ne fait pas partie de cette structure. == Eléments == <code javascript> {    type: nom de la structure    title: nom de l'élément } </code> === NOT_STRUCT === L'erreur se produit lorsqu'une propriété est demandée pour une variable qui n'est pas un type de classe == Eléments == <code javascript> {    type: type réel que la variable est (au lieu d'un type struct) } </code>

L'erreur se produit lorsqu'un index est demandé pour une variable qui n'est pas un tableau

{
   type: // type réel que la variable est (au lieu d'un type de tableau)
}

L'erreur se produit lorsqu'un index pour un tableau n'est pas un nombre ou un symbole

{
   type: 
}

L'erreur se produit lorsqu'une instruction de valeur (noeud de retour) est utilisée en dehors d'un message

{
   // vide
}

L'erreur se produit lorsqu'une expression a des types incompatibles

// left op right
{
    left:
    right:
    op:
}
// op value
{
    value:
    op:
}
// if, loop-go, loop-when
{
    exp: // expression type
    op: // if, while, repeat
} from: // provided type
// assign
{
    to: // to type
    op: "<-"
    from: // from type
}
// return
{
   op: "return"
   to: // type de return
   from: //type
}
// iteration (for i in exp go)
{
    op: "iteration"
    value: // the exp type
}
// typecast
{
    op: "typecast",
    to: // to type,
    from: // from type
}
 
=== LEXICAL ===
Ceci est une erreur lexicale.
 
== Eléments ==
{
    line: // le numéro de ligne
    text: // le texte de l'erreur
}
</ code>
 
=== SYNTAXE ===
Ceci est une erreur de syntaxe
 
== Eléments ==
<code javascript>
{
    line: // le numéro de ligne
    text: // le texte de l'erreur
    token: // le jeton obtenu
    expected: [] / la liste des jetons attendus
}

Pour un 0.5p supplémentaire, trouver le type de variables qui sont déclarées en utilisant juste une attribution.

Le devoir est individuel. Toute tentative de copiage entraînera 0p pour les devoirs. Système anti-copiage automatisé sera utilisé.

Si vous avez des questions concernant les devoirs, posez-les en postant un problème sur le github repository avec le format de titre [semantic] <votre titre de la question> . Vous aurez besoin d'un compte github pour cela.

Si vous souhaitez recevoir un e-mail lorsque des problèmes sont signalés ou lorsqu'il y a de nouveaux messages, accédez au site github repository et cliquez sur Watch .

Les devoirs seront testés automatiquement en utilisant un ensemble de tests publics et privés.

Vous pouvez télécharger les tests publics de GitHub repository.

Pour exécuter les tests, téléchargez le contenu du référentiel dans le directoire avec les devoirs. Entrez dans le directoire verify et exécutez ./run_all.sh.

cd verify
./run_all.sh

Vous aurez besoin de bash pour ça. Vous pouvez utiliser Linux ou Windows Linux Subsystem.

wget https://nodejs.org/dist/v8.9.4/node-v8.9.4-linux-x64.tar.xz
tar xvfJ node-v8.9.4-linux-x64.tar.xz
cd node-v8.9.4-linux-x64
sudo cp -R * /usr

Lors du téléchargement des devoirs, il est possible qu'on a des tests privés à faire passer. vmchecker les exécutera.

Le devoir doit être téléchargé sur vmchecker. Connectez-vous avec votre nom d'utilisateur moodle, sélectionnez le cours Automates et Langages Formelles (FILS) et téléchargez homework archive.

Le fichier readme a le format suivant:

Nom complet
Groupe

Une explication comment vous avez écrit vos devoirs, qu'avez vous utilisé, quelles sont les idées principales.

Pour télécharger vos devoirs, suivez les instructions suivantes:

1. Créer une archive zip (pas rar, ace, 7zip ou autre) conten
   • votre fichier principal
   • votre fichier grammar.jison
   • vos fichiers javascript (*.js)
   • le fichier package.json
   • le fichier Readme
2. Connectez-vous avec vmchecker
3. sélectionner les Automates et Langages Formelles (FILS) cours
4. sélectionnez 4. Sémantique
5. télécharger l'archive

Lorsque l'archive est téléchargée, vmchecker va exécuter:

unzip archive.zip homework
cd homework
npm install
echo '{ "node":true, "esnext":true }' > .jshintrc
jshint *.js