View difference between Paste ID: PRc2zCcW and 0fbUa8eR

 # Manipulation de fichiers
 	# File.write(fichier, texte)          - écrit à la suite du fichier
 	# File.rewrite(fichier, texte)        - réécrit tout le fichier
 	# File.writeline(fichier, texte)      - écrit dans une nouvelle ligne du fichier (à la fin)
 	# File.writefirstline(fichier, texte) - écrit dans une nouvelle ligne du fichier (au début)
 	# File.open(fichier, mode)            - permet d'ouvrir le fichier avec un mode
 	# File.read(fichier)                  - permet de lire le fichier
 	# File.readline(fichier, ligne)       - permet de lire une ligne spécifique du fichier
 	# File.close(fichier)                 - permet de fermer le fichier
 
 # Manipulation des textes
 	# String.lower(texte)  -
 	# String.upper(texte)  -
 	# String.length(texte) -
 
 # Manipulation de la console
 	# Console.clean.          - Efface tout le contenu (ce qui est écrit) de la console
 	# Console.print   "Texte" - Affiche un texte sur la ligne courante
 	# Console.println "Texte" - Affiche un texte sur une nouvelle ligne
 
 # Manipulation des int et des float
 	# Math.round 12.5  -
 	# Math.ceil 12.5   -
 	# Math.floor 12.5  -
 	# Math.random 12.5 -
 
 # Manipulation des tableaux
 	# Array.in(element, array) - Retourne true si l'element se trouve dans l'array
 	# Array.empty(array)       -
 	# Array.size(array)        -
 
 # Définition des variables globales
 	# *Non obligatoire signifie qu'il est possible de créer la fonction dans un script BM
 	# 	mais c'est mieux si nous on créer la fonction plutôt que de déléguer ça aux développeurs
 
 	opcodes = [
 		# fonction             entre  adresse
 		["nop",                 '\0', "\x00\x00"], #
 		["#",                   '\0', "\x00\x01"], #
-		["if",                  '(',  "\x00\x02"], #
+		["if",                  ' ',  "\x00\x02"], #
-		["elseif",              '(',  "\x00\x03"], #
+		["elseif",              ' ',  "\x00\x03"], #
 		["else",                '\0', "\x00\x04"], #
 		["end",                 '\0', "\x00\x05"], #
 		["continue",            '\0', "\x00\x06"], #
 		["break",               '\0', "\x00\x07"], #
 
 		["Program.exit",        '\0', "\x01\x00"], #
 
 		["Console.clean",       '\0', "\x02\x01"], #
 		["Console.print",       ' ',  "\x02\x01"], #
 		["Console.println",     ' ',  "\x02\x02"], #
 		["Console.sleep",       ' ',  "\x02\x03"], #
 
 		["String.lower",        '(',  "\x03\x00"], #
 		["String.upper",        '(',  "\x03\x01"], #
 		["String.length",       '(',  "\x03\x02"], #
 
 		["Math.floor",          '(',  "\x04\x00"], #
 		["Math.round",          '(',  "\x04\x01"], #
 		["Math.ceil",           '(',  "\x04\x02"], #
 		["Math.random",         '(',  "\x04\x03"], #
 
 		["Array.in",            '(',  "\x05\x00"], # Non obligatoire
 		["Array.empty",         '(',  "\x05\x01"], # Non obligatoire
 		["Array.size",          '(',  "\x05\x02"], # Non obligatoire
 
 		["File.open",           '(',  "\x06\x00"], #
 		["File.write",          '(',  "\x06\x01"], #
 		["File.writeLine",      '(',  "\x06\x02"], #
 		["File.writeFirstLine", '(',  "\x06\x03"], #
 		["File.rewrite",        '(',  "\x06\x04"], #
 		["File.isEmpty",        '(',  "\x06\x05"], #
 		["File.read",           '(',  "\x06\x06"], #
 		["File.readLine",       '(',  "\x06\x07"], #
 		["File.close",          '(',  "\x06\x08"], #
 		["File.countLine",      '(',  "\x06\x09"]  #
 	]
 
 	nbrWarnings = 0
 	nbrErrors   = 0
 
 # Fonction de compilation
 	compile (File Src, File Dst)
 		Data = [][]                 # contient le fichier source [ligne][colonne]
 		nbrLignes = File.countLine(Src) # nombre de lignes du fichier
 
 		print "Compilation de \"" . Src . "\" -> \"" . Dst . "\"...\n"
 
 		if File.open(Src, "r") == null # Si le fichier source est inaccessible en lecture on affiche une erreur
 			exit "Le fichier source \"" . Src . "\" n'a pu être ouvert en lecture."
 		end
 
 		for i = 0 to nbrLignes
 			if File.readline(Src, Data[i]) != 1
 				exit "Le fichier source \"" . Src . "\" n'a pu être lu correctement."
 			end
 
 			File.close(fpSrc)
 		end
 
 		if File.isEmpty(Src)
 			exit "Le fichier source \"" . Src . "\" est vide.\n"
 		end
 
 		if File.open(Dst, "wb") == null # Si le fichier de destination n'a pas pu être ouvert en écriture on affiche une erreur
 			exit "Le fichier de destination \"" . Dst . "\" n'a pu être ouvert en écriture."
 		end
 
 		File.write(Dst, "BM01")
 
 		for y = 0 to nbrLignes
 			if Data[y][0] == '\0'
 				continue
 			end
 
 			for x = 0 to Array.size(opcodes)
 				if Array.in(Data[y][x], opcodes)
 					File.write(Dst, [j].code)
 					k = 0
 
 					# ---------------------------- #
 					# début partie en modification #
 					# ---------------------------- #
 					if [j].nextCar != '\0'
 						if [j].nextCar == ' '
 							for (k=strlen (opcodes [j].str) ; Data [y][k]==' ' && k < strlen (Data [y]) ; k++)
 							end
 						else
 							for (k=strlen (opcodes [j].str) ; (Data [y][k]!=opcodes [j].nextCar || Data [y][k]==' ') && k < strlen (Data [y]) ; k++)
 							end
 						end
 
 						if k >= strlen (Data[y])
 							exit "Instruction invalide dans le fichier " . Src . ":" . (y + 1) . "."
 							break
 						end
 					end
 					# -------------------------- #
 					# fin partie en modification #
 					# -------------------------- #
 				else.
 					exit "Instruction inconnue : \"" . Data[y] . "\" dans le fichier " . Src . ":" . (y + 1) . "."
 				end
 			end
 		end
 
 		File.close(Dst)
 		print "Compilation terminée (" . nbrErrors . " erreur(s) et " . nbrWarnings . " warning(s))"
 
 		if (nbrErrors > 0)
 			return false
 		end
 
 		return true
 	end
 
 
 
 
 Syntaxe d’un objet BootMonkey
 (Fichier binaire exécutable)
 
 Signature (sur 4 octets) : “BM01”. Sans cette signature, l’exécutable .rbm NE pourra PAS être exécuté !
 Puis :
 
 Pour chaque instruction (non conditionnelle):
 
         code de l’instruction (2 octets).
         adresse de l’instruction suivante à partir du début du fichier (4 octets).
         nombre de paramètres (sur 1 octet)
             Pour chaque paramètre :
 
     - Son type (1 octets)
 
         - Le premier demi-octet : Type de variable (1=constante immédiate/0=adresse d’une variable).
 
         - Le deuxième demi-octet : Taille de la variable (1 ou 2 ou 4 / 4 obligatoire pour l’adresse d’une variable).
 
     - Son contenu (1 ou 2 ou 4 octets)
 
         En fonction du type.
 
 
 
 
 
 // PISTES
 
 
 				switch (opcodes [j].nextCar)
 				{
 					case ' ':
 					{
 						// ArgsSize est la taille de l'argument passé en paramètre.
 						uint32_t ArgsSize = strlen (Data [i]) - k ;
 						// ArgsSize + 1 pour prendre en compte le '\0' de fin de chaîne.
 						uint8_t *Var = malloc (ArgsSize + 1) ;
 						memcpy (Var, &Data [i][k], ArgsSize + 1) ;
 
 						// ArgsSize - 1 car ArgsSize est un tableau, donc pour utiliser le dernier paramètre
 						if (Var [0] == '\"' && Var [ArgsSize - 1] == '\"')
 						{
 							// addr est l'adresse de l'instruction suivante.
 							uint32_t addr = ftell (fpDst) + 4 + (ArgsSize - 2) + 1 ;
 							uint32_t fill = 0 ;
 							fwrite (&addr, 1, 4, fpDst) ;
 							for (uint32_t k=1 ; k < ArgsSize-1 ; k++)
 							{
 								if (Var [k] == '\\' && k+1 < ArgsSize-1)
 								{
 									switch (Var [++k])
 									{
 										case '\\':
 											Var [k] = '\\' ;
 											break ;
 										case '\"':
 											Var [k] = '\"' ;
 											break ;
 										case '\'':
 											Var [k] = '\'' ;
 											break ;
 										case 'a':
 											Var [k] = '\a' ;
 											break ;
 										case 'b':
 											Var [k] = '\b' ;
 											break ;
 										case 'e':
 											Var [k] = '\e' ;
 											break ;
 										case 'f':
 											Var [k] = '\f' ;
 											break ;
 										case 'n':
 											Var [k] = '\n' ;
 											break ;
 										case 'r':
 											Var [k] = '\r' ;
 											break ;
 										case 't':
 											Var [k] = '\t' ;
 											break ;
 										case 'v':
 											Var [k] = '\v' ;
 											break ;
 										default:
 											warning ("Séquence d'échappement invalide \"\\%c\" dans le fichier %s:%d, utilisation du caractère sans échappement.", Var [k], Src, i+1) ;
 											break ;
 									}
 									fill++ ;
 								}
 
 								fprintf (fpDst, "%c", Var [k]) ;
 							}
 							fwrite ("\0", 1, 1, fpDst) ;
 							while (fill-- > 0)
 								fwrite ("\0", 1, 1, fpDst) ;
 						}
 						else if (isdigit (Var [0]))
 						{
 							uint32_t addr = ftell (fpDst) + 4 + ArgsSize + 1 ;
 							fwrite (&addr, 1, 4, fpDst) ;
 							fprintf (fpDst, "%d", atoi (&Var [0])) ;
 							fwrite ("\0", 1, 1, fpDst) ;
 						}
 						else
 							dieOnError ("Déclaration de constante immédiate illégale dans le fichier %s:%d.", Src, i+1) ;
 						free (Var) ;
 						break ;
 					}
 				}
 				break ;
 			}
 		}
 		if (j >= NbrOpCodes)
 			dieOnError ("Instruction inconnue : \"%s\" dans le fichier %s:%d.", Data [i], Src, i+1) ;
 	}
 	fclose (fpDst) ;
 	fprintf (stdout, "Compilation terminée (%d erreur", nbrErrors) ;
 	if (nbrErrors > 1)
 		fprintf (stdout, "s") ;
 	fprintf (stdout, " et %d warning", nbrWarnings) ;
 	if (nbrWarnings > 1)
 		fprintf (stdout, "s") ;
 	fprintf (stdout, ").\n") ;
 	if (nbrErrors > 0)
 		return EXIT_FAILURE ;
 	return EXIT_SUCCESS ;
 }