Le but du devoir est d'écrire l'analyse sémantique, le langage intermédiaire 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. ajouter à chaque noeud d'AST un attribut symbole avec l'ID de contexte et déterminer les types pour les noeuds qui retournent (expression, value, id, element_of_array, element_of_struct elements, value_of_function)
3. la liste d'erreurs sémantiques

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 tableau d'objets de contexte.

[
   // ID de l'objet de contexte 0 - le contexte du script principal
   {
      ...
   },
   // ID de l'objet de contexte 1 - l'objet de contexte d'une fonction
   {
      ...
   },
   ...
]

Lors de la détermination de la table de symboles, ajoutez à chaque noeud AST un paramètre symbole avec la valeur de son identifiant de contexte.

Les objets de contexte stockent

• la variable déclarée dans ce contexte
• le message déclaré dans ce contexte
• les classes déclarées dans ce contexte
• l'identifiant de contexte parent (position dans le tableau symbol_table)
• le type du contexte (module ou message)
• le nom du message duquel est le contexte (s'il n'est pas le module)
• le nom de la classe duquel est le contexte (s'il n'est pas le module)
• le type de la valeur de retour du message duquel est le contexte (s'il n'est pas le module)

L'objet ressemble à:

{
   "variables": {// un dictionnaire des variables
      "Nom de la variable": {
         "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)
      }
   },
   "messages": {// un dictionnaire des fonctions
      "message_name": {
         "type": // le type de retour de la fonction
         "parametres": [] // 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
         "symbol": // l'identifiant de l'objet de contexte créé par la fonction
 
      }
   },
   "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
               "from": // le premier index
               "to": // le dernier index
               // pour la classe
               "elements": [// une liste d'éléments de tableau (le noeud de l'AST)
                  {
                     "type":
                     "id":
                     "line":
                  },
                  ...
               ]
            }
   },
   "parent": 0, // la position du contexte parent dans le tableau symbol_table (à l'exception du script principal qui n'a pas de parent), généralement 0,
   "type": //
   "message": // le nom du message s'il s'agit d'un contexte de fonction
   "class": // le nom de la classe si le contexte est dans un message qui est dans une classe
   "return_value": // le type de retour de la fonction s'il s'agit d'un contexte de fonction
}

{
   "variables": {
      "s": {
         "type": "school",
         "line": 8
      }
   },
   "messages": {},
   "types": {
      "school": {
         "type": "class",
         "line": 6,
         "elements": [
            {
               "type": "int",
               "id": "type",
               "line": 5
            },
            {
               "type": "logic",
               "id": "private",
               "line": 4
            },
            {
               "type": "string",
               "id": "name",
               "line": 3
            }
         ]
      }
   }
}

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

• exp
• value
• identifier
• return
• element
• property
• dispatch

Définissez le type en ajoutant une propriété type dans le noeud.

{   
   "id": "exp",
   "op": "=",
   "left": {
      "id": "exp",
      "op": "mod",
      "left": {
         "id": "id",
         "value": "n",
         "line": 8,
         "symbol": 1,
         "type": "int"
      },
      "right": {
         "id": "id",
         "value": "i",
         "line": 8,
         "symbol": 1,
         "type": "int"
      },
      "line": 8,
      "symbol": 1,
      "t": "int"
   },
   "right": {
      "id": "value",
      "type": "int",
      "value": 0,
      "line": 8,
      "symbol": 1
   },
   "line": 8,
   "symbol": 1,
   "type": "logic"
}

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
    line: // le numéro de ligne dans la source (commençant par 1)
    elements: // éléments pour l'erreur, chaque type d'erreur a des éléments différents
    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.

{
    struct: // nom du type de structure
    element: // 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
    low_index: // la valeur d'index inférieure
    high_index: // la valeur d'index la plus élevée
}

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
}
// Elément struct
{
    struct: // nom du type de structure
    element: // 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.

{
   id: // 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é.

{     variable: la variable qui a ce type     type: le type qui n'est pas défini }

L'erreur se produit lorsqu'un élément ne fait pas partie de cette structure.

{
   class: // nom de la structure
   propriété: // nom de l'élément
}

L'erreur se produit lorsqu'une propriété est demandée pour une variable qui n'est pas un type de classe

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

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

{
   array: // type de tableau
   index: // type d'index fourni
}

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, while or repeat
{
    expression: // expression type
    op: // if, while, repeat
}
// for
{
    expression: // expression type
    op: "for"
    element:
}
// value_of_function
{
    op: "value"
    to: // return type
    from: // provided type
}
// assign
{
    op: ":="
    to: // to type
    from: // from type
}
// struct element type is undefined
{
    struct: // struct type,
    element: // name of struct element
}
// variable type is undefined
{
    variable: // name of the variable
}

Ceci est une erreur lexicale.

{
    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