Show page

Differences

This shows you the differences between two versions of the page.

--- alf:teme:tema5 [2017/07/31 16:42]
alexandru.radovici
+++ alf:teme:tema5 [2022/05/22 19:57] (current)
diana.ghindaoanu
@@ Line 1: / Line 1: @@
-====== Devoir 5 – Langage SuperFILS ======
+====== Devoir 5 – Web Assembly ======
 ===== Information =====
 <note important>
-Date limite: **3 Septembre, 23:55**\\
+Date limite: **3 juin, 23:55**\\
-Points: **5 points** de la note finale\\
+Points: **2 points** de la note finale\\
-Surcharger le devoir: [[https://vmchecker.cs.pub.ro|vmchecker.cs.pub.ro]]\\
 </note>
 ===== Demande =====
-Parsez le fichier source SUPERFILS et générez un arbre de syntaxe abstraite JSON(AST).
+Le but de ce devoir est de traduire un Langage Alf fourni sous forme de fichier AST avec des données sémantiques dans Web Assembly. Votre programme recevra deux paramètres: le fichier source (le fichier des devoirs précédents, avec la table des symboles, l'AST et la liste des erreurs) et le fichier de sortie. **Vous n'avez pas besoin d'une version correcte du devoir 4!** Les fichiers de test ont déjà été générés et vous pouvez les trouver sur [[https://github.com/upb-fils/alf/tree/master/Devoirs/assembly/verify/assembly|github]]. Les programmes auront n'importe quel type de variable. La concaténation de chaînes n'est pas fournie (à l'exception de quelques tests de test).
-Le devoir reçoit un ou deux paramètres de la ligne de commande. Le premier paramètre est le nom du fichier avec le script SuperFILS, le deuxième est le fichier de sortie. Si le fichier de sortie manque, son nom est identique au fichier de sortie, en ajoutant l'extension ".json".
 <code bash>
-node main.js script.sf script.sf.json
+node main.js fisier.alf.json fisier.alf.opt.json fisier.wat [optimisations,]
 </code>
-===== Conseils =====
+<note>
-Ici il y a des conseils pour résoudre le devoir:
+Le fichier AST est considéré comme correct.
-  * commencez avec les règles pour les valeurs
+</note>
-  * ajoutez les règles pour les expressions
-  * ajoutez les règles pour les définitions des variables
-  * ajoutez les règles pour les boucles
-  * ajoutez les règles pour les définitions des fonctions
-  * ajoutez les règles pour l’exécution des fonctions
-  * ajoutez les règles pour les branches et boucles
-  * ajoutez les règles pour array et struct
- Essayez d'exécuter de petits scripts pour tester toutes les fonctionnalités.
+Vous devez écrire deux fichiers:
-===== Mise en évidence de la syntaxe =====
+   * le fichier WAT (fichier texte)
+   * un fichier JSON avec l'AST traité afin que la table des symboles reflète l'allocation des variables. Les tests vérifieront uniquement la table symbol_table. Vous pouvez y ajouter des propriétés supplémentaires.
-Si vous utilisez Sublime Text, vous pourriez utiliser cela [[https://github.com/alexandruradovici/alf-alfy-language-public/blob/master/alfy.tmLanguage|fichier mise en évidence de la syntaxe]] pour écrire le langage SuperFILS.
-Vous pouvez [[http://stackoverflow.com/questions/12785583/add-ts-language-files-to-sublime-text-to-support-additional-syntax-coloring|lire]] ici comment ajouter le fichier.
+===== Types de variables =====
-===== Format AST =====
+Les variables sont divisées en deux types:
-Tous les noeuds de l'AST ont la forme suivante:
+   * simple - variables de type int, real, bool et character
+   * complexe - array et struct
+   * strings
+Nous en discuterons en détail. Chaque type de variable d'ALF doit être traduit dans un type WebAssembly suivant le tableau.
-<code javascript>
+<note>
-{
+Les types de variables simples sont alloués en tant que variables WebAssembly, tandis que les chaînes complexes et sont allouées dans l'espace mémoire.
-  type:"node_type"
+Les variables Complex et Strings sont traitées comme une valeur de pointeur (i32) vers la position en mémoire.
-}
-</code>
-La liste des types de noeuds est la suivante:
-  * script - un script
-  * define – définition de variable
-  * expression – n’importe quelle expression
-  * attribution - définition de la valeur d'une variable
-  * define_function - définition de la fonction
-  * struct - définition d’une structure
-  * element_of_struct - un element d’une structure
-  * array - définition d’un array
-  * element_of_array - un élément d’un array
-  * if - if statement
-  * while - while statement
-  * repeat - repeat statement
-  * for - for statement
-  * valueof – exécuter une fonction
-  * value_of_function - valeur d’une fonction
-  * value - une valeur (int, real, logic, float, user_defined)
-===== SuperFILS =====
-Le langage est un langage typé SuperFILS défini comme:
-* Définitions des variables
-* Définitions des fonctions
-* Définitions des structures (nouveau type de données)
-* Définitions des arrays (nouveau type de données)
-* Expressions
-* Valeurs
-* Attributions
-* Exécution des fonctions
-* Branche (if)
-* Boucle (while, for ou repeat)
-<Note>
-Les instructions sont séparées par des lignes nouvelles. Cela signifie qu'il n'y a qu'une seule instruction sur une ligne.
-<code>
-a <- 10
-b <- 5
-</code>
 </note>
+^ ALF Type ^ WebAssembly Type ^
+| int | i32 |
+| real | i32 |
+| character | i32 |
+| bool | i32 |
+| string | a 256 bytes memory space |
+| array (type:[from -- to]) | a bytes * length memory space |
+| struct | a sum of the struct's properties bytes memory space |
-==== Notations ====
-  * [facultatif] – tout ce qui se trouve entre [] est une partie facultative
-==== Valeurs ====
+==== Valeurs des variables ====
-Les valeurs sont:
-  * int nombre <code>7</code>
-  * float nombre <code>7.5</code>
-  * symbol <code>"s"</code>
-  * string <code>"this is a text"</code>
-  * boolean (valeur true ou false) <code>false</code>
-  * la valeur vide <code>null</code>
-<note info>
+===int===
-Les strings peuvent avoir les caractères spéciaux suivants:
+Toutes ces valeurs sont représentées par i32.
-  * " - noté \"
-  * \ - noté %%\\%%
-  * \r - noté \r
-  * \n - noté \n
-</note>
-==== Commentaires ====
+===real===
-Les commentaires sont des parties ignorées du fichier source. Ils sont enfermés entre "<*" et "*>" et ne sont pas imbriqués.
+Toutes ces valeurs sont représentées par f32.
-<note> Les commentaires peuvent s'étendre sur plusieurs lignes. </note>
+===character===
+Toutes ces valeurs sont représentées par i32, en ascii.
+===bool===
+La valeur bool est représentée par:
-<note> Tous les fichiers de test ont des commentaires sur la première ligne. Si votre grammaire n'a pas de règles pour les commentaires, sautez simplement la première ligne. </note>
+   * true - i32, valeur 1
+   * false - i32, valeur 0
-<code>
+===String===
-<*Texte pour décrire le script*>
+La représentation utilisée pour les chaînes est de type Pascal et a une longueur de 256 octets:
-  var a:float
-</code>
-==== Identificateur ====
+   * 1 octet pour la longueur
-Un identificateur peut être n'importe quelle valeur qui commence par une lettre, %% $ %% ou %% _ %% et qui peut contenir aussi des nombres dans son nom.
+   * 255 octets pour les symboles
-<code>
+{{ :alf:teme:strings.png?nolink&300 |}}
-identifier
-$identifier
+===== Règles pour l'allocation des variables =====
-_identifier
-</code>
-=== AST ===
+Les variables peuvent être attribuées différemment en fonction de leur type et de leur position. Les types d'allocation sont ''globla'', ''data'', ''param'', ''local'', ''stack'' et ''relocated''.
-<code javascript>
-{
-	type:"identifier",
- 	id:"identifier_name"
-}
-</code>
+^ Variable Type ^ Variable Location ^ Allocation Type ^
+| simple   | script   | global           |
+| complex  | script   | data            |
+| string   | script   | data            |
+| simple | function parameter | param          |
+| complex | function parameter | param (sent as pointer, see note)      |
+| string | function parameter | param (sent as pointer, see note)      |
+| simple   | function | local           |
+| complex  | function   | stack           |
+| string   | function   | stack           |
+| simple   | if, for, loop | relocated           |
+| complex  | if, for, loop   | relocated           |
+| string   | if, for, loop   | relocated           |
-==== Valeur ====
-Une valeur est un nombre entier, un nombre réel, un logique (true ou false) ou une chaîne de caractères.
-=== Langage ===
+=== Allocation de type global===
-<code>
+Les variables allouées comme ''global'' sont des variables simples du script principal. Celles-ci seront attribuées en tant qu'instructions ''(global $title type)'' . Exemple: [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/1_variable_definition/simple.alf|simple.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/1_variable_definition/simple.alf.wat|simple.wat]]
-.432
-true
-"a"
-"string"
-</code>
-=== AST ===
+L'accès à ces variables se fait à l'aide des instructions ''global.set'' et ''global.get''.
-<code javascript>
-{
- 	type:"value",
-	t:"value_type", // int, float, symbol, boolean, string
- 	value:actual_value
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/value|Example]]
-==== Définitions des variables ====
+=== Allocation de type data===
-=== Langage ===
+Les variables allouées comme ''data'' sont des variables complexes et des chaînes du script principal. Ceux-ci seront alloués comme dans l'espace mémoire. Chaque variable de ce type aura un paramètre ''address'' avec la position de la variable en mémoire. Exemple: [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/1_variable_definition/simple.alf|simple.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/1_variable_definition/simple.alf.wat|simple.wat]].
-<code>
+L'accès à ces variables se fait à l'aide des instructions ''i32.load'' et ''i32.store'' pour charger et stocker l'adresse de variable dans la pile de données.
-var variable_name :[variable_type] [<- value or expression], ...
-</code>
-=== Exemples ===
-<code>
-var a:int <- 5
-var b:float
-var c:<- true, d:<- 4.5
-</code>
-== Types de données ==
+<note>
+Vous pouvez ajouter une variable ''(global $title i32 (i32.const address_of_variable)'' pour faciliter la lecture du code.
+</note>
-  * int - nombre entier
-  * float - nombre à virgule flottante
-  * symbol - un seul character
-  * string - texte
-  * boolean - true ou false
-  * défini par l'utilisateur (struct, array)
-=== AST ===
+===Allocation de type param===
+L'allocation de paramètres est utilisée pour les paramètres de fonction de type simple. Celles-ci seront allouées en tant qu'instructions ''(param $title type)'' dans la définition de la fonction. Exemple: [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/6_function/definition_variables.alf|definition_variables.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/6_function/definition_variables.alf.wat|definition_variables.wat]].
-<code javascript>
+L'accès à ces variables se fait à l'aide des instructions ''local.set'' et ''local.get''.
-{
-	type:"define",
- 	elements:[ // array of variables
- 		{
- 			type:"data type",
- 			id: "variable name"
- 		},
-	]
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/variable_definition|Example]]
+=== Allocation de type local ===
+Les variables allouées comme local sont de simples variables issues d'une fonction. Celles-ci seront affectées en tant qu'instructions ''(local $title type)'' dans la définition de la fonction. Exemple: [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/6_function/definition_variables.alf|definition_variables.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/6_function/definition_variables.alf.wat|definition_variables.wat]].
-==== Struct ====
+L'accès à ces variables se fait à l'aide des instructions ''local.set'' et ''local.get''.
-=== Langage ===
+===Allocation de type stack===
-<code>
-struct struct_name:
-	var element_name:data_type [<- initial_value]
-	...
-	...
-endstruct
-</code>
-=== AST ===
+Les variables attribuées à la pile sont des variables complexes et des chaînes d'une fonction. Ceux-ci seront alloués comme dans l'espace mémoire d'une pile simulée. Chaque variable de ce type aura un paramètre ''address'' avec la position de la variable en mémoire liée à un pointeur de base de pile.
-<code javascript>
-{
-	type:"struct",
-	id:"struct_name",
- 	elements:[ // array of elements
- 		{
- 			type:"element data type",
- 			id: "element name",
- 			value: "element value" // if it exists
- 		}
-	]
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/struct|Example]]
+Pour simuler une pile, vous devez déclarer une variable globale (dans notre exemple ''$stack_pointer'') et une variable locale dans chaque fonction (dans notre exemple ''$base_pointer''). Chaque fois que vous entrez une fonction, stockez la valeur de ''$stack_pointer'' dans ''$base_pointer''. Chaque fois que vous quittez une fonction (retour ou fin de fonction), retournez le ''$stack_pointer'' d'origine à partir de ''$base_pointer''.
-==== Array ====
+Les adresses variables sont calculées par rapport au ''$base_pointer''. Par exemple, si vous avez une variable avec l'adresse 100, l'adresse réelle de la variable sera ''$base_pointer'' + 100.
-=== Définitions des Arrays ===
+Exemple: [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/6_function/definition_variables_stack.alf|definition_variables_stack.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/6_function/definition_variables_stack.alf.wat|definition_variables_stack.alf.wat]].
-== Langage ==
+<note>
-<code>
+Vous pouvez ajouter une variable ''(local $title i32)'' et définir sa valeur comme ''(local.set $title address_of_variable)'' pour faciliter la lecture du code.
-array array_name:data_type integer_number, integer_number
-</code>
-== AST ==
-<code javascript>
-{
-	type:"array",
-        id: array_name,
-	element_type: elements_data_type,
- 	from: from_integer_number,
- 	to: to_integer_number
-}
-</code>
-=== Array accès ===
-== Langage ==
-<code>
-array_name[index]
-</code>
-== AST ==
-<code javascript>
-{
-	type: "element_of_array",
-	array: array_identifier,
- 	index: index_identifier
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/array|Example]]
-==== Expressions ====
-=== Priorité des opérateurs ===
-^ Operator ^ Precedence ^
-| = != | Low |
-| > >= < <= | |
-| and or xor | |
-| not | |
-| + - | |
-| * / mod | High |
-=== Langage ===
-<code>
-.6 + 5
-* 10 + 19
-variable + 5
-x > y
-x = y
-+ (x + y) * (5 + 6)
-</code>
-=== AST ===
-<code javascript>
-{
-	type:"expression",
-	op:"operator",
- 	left:left_operand,
- 	right:right_operand
-}
-</code>
- <Note> L'opérateur '-' a un AST différent s'il est utilisé comme un unaire (ex: -50)
-<code javascript>
-{
-	type:"expression",
-	op:"negative",
- 	value:50
-}
-</code>
 </note>
-==== Attribution ====
+===Allocation de type relocated===
+Les variables de type relocated sont toutes les variables déclarées dans un if, loop ou for. Celles-ci seront déplacées (relocated) en tant que variables globales si l'instruction est dans un script ou en tant que variables locales si l'instruction est dans une fonction. La variable sera renommée en ''$(node.symbol_table)+_+variable.title''.
-=== Language ===
+Exemple: [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/4_branch/local_variable.alf|local_variable.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/4_branch/local_variable.alf.wat|local_variable.alf.wat]]
-<code>
+==== Script principal ====
-variable <- expression
+Votre script principal (section de ''script'' de l'ast sémantique) sera la fonction dans webassembly. Le nom de la fonction dépend de vous.
-</code>
-=== Exemples ===
-<code>
-x <- 1000
-s <- "text" + "s"
-y <- valueof f -> ()
-a[i] <- 900
-q.element <- "this is a text"
-</code>
-=== AST ===
+==== Importations ====
+Une valeur est un nombre entier, un nombre réel, un logique (true ou false) ou une chaîne de caractères.
-<code javascript>
+Certaines fonctions de la table des symboles ont un paramètre ''use''. Cela signifie que ces fonctions sont importées du module déclaré dans la propriété ''use''.
-{
-	type:"attribution",
- 	to: {
- 	 	... id, element_of_struct, element_of_array
- 	},
- 	from: {
- 	 	... expression
- 	}
-}
-</code>
-==== Définitions des fonctions ====
+Exemple: [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/2_simple/real_number.alf|2_simple/real_number.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/2_simple/real_number.alf.json|real_number.alf.json]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/2_simple/real_number.alf.wat|real_number.alf.wat]]
-=== Langage ===
+==== Strings ====
-<code>
+Toutes les constantes string (valeurs) sont stockées dans la mémoire principale juste après les variables globales. Vous pouvez utiliser ''(data (i32.const address) "\SSvalue")'', où SS est la valeur base16 de la longueur. Le premier octet de la chaîne représente la longueur de la chaîne.
-function function_name:[function_type][(parameter1:parameter1_type, ...)] return statement;
-</code>
-<code>
+Exemple [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/1_variable_definition/string.alf|string.alf]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/1_variable_definition/string.alf.opt.json|string.alf.opt.json]] [[https://github.com/UPB-FILS/alf/blob/master/Devoir/assembly/verify/assembly/1_variable_definition/string.alf.wat|string.alf.wat]]
-function function_name:[function_type][(parameter1:parameter1_type, ...)] {
-statemet
-...
-statement
-}
-</code>
-=== Exemples ===
+===== Étapes pour écrire le devoir =====
-<code>
-function f:(x:int, y:float) {
-  var a: <- x + y
-  return a
-}
-</code>
-<code>
+   * Calculez l'allocation pour chaque variable
-function f:float (x:int, y:float) return x + y
+   * Transformez chaque élément AST en instruction(s) Web Assembly correspondante(s)
-</code>
+   * Transformez chaque fonction (et ses instructions) en instructions de webassembly correspondantes
-<code>
+===== Optimisation bonus=====
-function f:float (x:int, y:float){
-  var p:int
-  var i:int
-  if n = 0 {
-    for i, 1 to n, 1 {
-      p = p * a
-    }
-  }
-  return p
-}
-</code>
+Implémentez le devoir de manière à ce qu'ils effectuent les optimisations suivantes:
+   * constant folding
+   * supprimer les variables et fonctions inutilisées
+Pour le bonus, il y a 2 parametres supplementaires dans la ligne de commande:
-=== AST ===
-<code javascript>
-{
-	type:"define_function",
-	id:"function_name",
-	parameters:[ // array of parameters
- 		{
- 			type:"data type",
- 			id: "parameter name"
- 		},
- 	],
-	value_type:"le type retourné par la fonction",
-	statements:[ // array des intructions (meme s'il y a seulement un)
-		...
- 	]
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/function|Example]]
-=== Valeur d’une fonction  ===
-Il s'agit des instructions qui définissent la valeur de retour de la fonction.
-== Exemple ==
-<code>
-return x + y
-</code>
-== AST ==
-<code javascript>
-{
-	type:"value_of_function",
-	value: {
-		...
-	}
-}
-</code>
-==== Exécution des Fonctions ====
-=== Langage ===
-Il existe seulement un façon d'exécuter une fonction: en utilisant valueof.
-<code>
-valueof function_name -> ([parameter1 <- expression1, parameter2 <- expression2, parameter3 <- expression3, ...)]
-</code>
-=== Exemples ===
-<code>
-s <- valueof sum -> (n1 <- 3, n2 <- 5)
-valueof getdir -> ()
-</code>
-=== AST ===
-<code javascript>
-{
-	type:"valueof",
-	function:
- 		{
- 			id:"function_name",
- 		},
-	parameters:{ // dictionnaire des valeurs des parametres
- 		"parameter1": parameter_value,
- 		...
- 	}
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/function|Example]]
-==== Branche ====
-=== Langage ===
-<code>
-if expression {
-  ...
-}
-</code>
-<code>
-if expression {
-  ...
-}
-elseif {
-  ...
-}
-else{
-  ...
-}
-</code>
-=== AST ===
-<code javascript>
-{
-	type:"if",
-	expression: expression,
-	then: [ // liste d'instructions
-	]
-}
-</code>
-<code javascript>
-{
-	type:"if",
-	expression:expression,
-	then: [ // liste d'instructions
-	],
-	else: [ // liste d'instructions
-	]
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/branch|Example]]
-==== Loop ====
-Il y a deux types de boucles: while et for.
-=== while ===
-<code>
-while expression {
-  ...
-}
-</code>
-<code>
-do {
-  ...
-} while expression
-</code>
-== AST ==
-<code javascript>
-{
-	type:"while",
-	expression:expression,
-	statements: [ // liste d'instructions
-	]
-}
-</code>
-=== for ===
-<code>
-for variable_name, expression to expression, expression_for_nr_of_steps {
-   ...
-}
-</code>
-== AST ==
-<code javascript>
-{
-	type:"for",
-  variable:variable_name,
-	from:expression,
-	to:expression,
-	step:expression,
-	statements: [ // liste d'instructions
-	]
-}
-</code>
-[[https://github.com/alexandruradovici/alf-alfy-language-public/tree/master/verify/alfy/loop|Example]]
-===== Erreurs =====
-Si le fichier source a des erreurs, vous devez avoir un output dans le JSON avec l`erreur. Il y a deux types des erreurs:
- 	* lexicale (token inconnu)
- 	* syntaxe (token inattendu)
-==== Lexicale ====
-Pour n'importe quel erreur lexicale, on a:
-<code javascript>
-{
-	error:"lexical",
- 	line: line_number,
- 	text: "text that is not recognised"
-}
-</code>
-==== Syntaxe ====
-Pour n'importe quel erreur de syntaxe, on a:
-<code javascript>
-{
- 	error:"syntax",
- 	line: line_number,
- 	token: "token that the parser saw", // le nom du token ne va pas être vérifié par le checker
- 	expected: [liste des tokens attendus] // le nom du token ne va pas être vérifié par le checker
- }
- </code>
-<note warning>
-Les noms des tokens seront différents pour chacun d`entre vous, il seront ignorés par le checker. Le checker vérifiera seulement si vous avez un token dans le token item et dans la liste.
-</note>
-<note>Le nombre des lignes commence avec 1</note>
-===== Tester =====
-Le devoir va être testé automatiquement en utilisant un set avec des tests publics et privés.
-==== Les tests publics ====
-Vous pouvez télécharger les tests publics de GitHub [[https://github.com/alexandruradovici/alf-alfy-language-public|repository]].
-Pour exécuter les tests, télécharger le contenu du repository dans un dossier avec le devoir. Entrez dans le dossier //verify// et exécuter ./run_all.sh.
 <code bash>
-cd verify
+node main.js fisier.alf.json fisier.alf.opt.json fisier.wat [fold_constants] [unused]
-./run_all.sh
 </code>
-Vous devez avoir bash pour faire ça. Vous pouvez utiliser soit Linux, soit [[https://msdn.microsoft.com/en-us/commandline/wsl/install_guide|Windows Linux Subsystem]].
 <note>
-Pour installer nodejs en Linux ou Windows Linux Subsystem, suivez les pas suivants:
+[] signifie qu'il s'agit de quelque chose d'optionnel
-<code bash>
-wget https://nodejs.org/dist/v6.10.0/node-v6.10.0-linux-x64.tar.xz
-tar xvfJ node-v6.10.0-linux-x64.tar.xz
-cd node-v6.10.0-linux-x64
-sudo cp -R * /usr
-</code>
 </note>
-==== Les tests privés ====
-Quand vous téléchargez le devoir, c`est possible que vous avez des tests nécéssaires qu`il doit passer. vmcheker va les exécuter.
-<note>
-Vous pouvez télécharger le devoir autant que des fois que vous voulez jusqu`à la date limite. Il va exécuter tous les tests pour vous et il va afficher les résultats.
-</note>
-===== Télécharger le devoir =====
-Le devoir doit être télécharger sur [[https://vmchecker.cs.pub.ro|vmchecker]]. Connectez vous avec votre nom d`utilisateur de moodle, séléctionnez le course //Automates et Langages Formelles (FILS)// et téléchargez le [[#homework-archive|homework archive]].
-==== Readme ====
-Le fichier Readme doit avoir le format suivant:
-<code>
-Votre nom complet
-Groupe
-Une explication comment vous avez écrit le devoir, qu`est-ce que vous avez utilisé, quels sont les idées principales.
-</code>
-==== Archive du Devoir ====
-Pour télécharger le devoir, je vous en prie de suivre les pas suivants:
-  - Créer une archive ZIP (pas un rar, ace, 7zip ou quelque chose d`autre) qui contient:
-    * le fichier main (main.js)
-    * les fichiers javascript (*.js)
-    * le fichier jison (alfy.jison)
-    * yarn.lock (si vous utilisez yarn)
-    * le fichier package.json
-    * le fichier Readme
-  - connecter avec [[https://vmchecker.cs.pub.ro|vmchecker]]
-  - sélectionner le course //Automates et Langages Formelles (FILS)//
-  - sélectionner //5. Langage SuperFILS//
-  - télécharger l`archive
-<note>
-L`archive doit contenir les fichiers dans la racine et pas dans un dossier. NE PAS archiver un dossier avec les fichiers, archiver DIRECTEMENT les fichiers.
-NE PAS inclure //node_modules//.
-</note>
-Quand l`archive est téléchargée, vmcheker va tester:
-<code bash>
-unzip archive.zip homework
-cd homework
-# if the file yarn.lock exists
-yarn
-# else
-npm install
-echo '{ "node":true, "loopfunc": true, "esnext":true }' > .jshintrc
-jshint *.js
-jison alfy.jison -o alfy.js
-</code>

Cours

TP

Simplifiee

Seminaires

Devoir

Ressources

alf/teme/tema5.1501508522.txt.gz · Last modified: 2017/07/31 16:42 by alexandru.radovici

Show page Old revisions

Media Manager Back to top