Bonsoir,

J´ai un projet a faire en java, je dois ecrire un programme qui joue le rôle d´assembleur, mais j´ai du mal a cerner le sujet. Je vous cite le sujet:

"Pour rappel, l´assembleur est le programme qui traduit les instructions en
langage d´assemblage vers du code binaire. On considère ici
uniquement la fonction de traduction des instructions machines, et le calcul des
adresses. L´assembleur prend en entrée un fichier texte contenant le
programme. Il produit en sortie un listing des instructions et un fichier binaire
contenant le programme."

Donc si vous pouviez me l´expliquer plus concrètement, et me donnez quelques pistes pour débuter sur ce projet.

J´ai déja programmé en java, je dirais meme que je programme en java, mais sur des choses plus concretes, la le sujet est trop abstrait et me dépasse. Merci d´avance de votre aide.

j´ai pas bien compris ce que tu devais faire.
quel est la sémantique de ton langage de base
quel est la sémantique de ton langage bas niveau ?

Je m´explique mieux :

Je dois donc réaliser un programme java qui joue le rôle d´assembleur. L´assembleur est une sorte de traducteur qui prend en entrée un fichier texte d´un programme en langage assembleur, et doit donc mettre en sortie ce fichier texte en langage machine (en binaire). Voila un bref exemple de ce que doit realiser mon programme :

Assembler---------Machine Code------------------Explanation
MOV AL,15---------D0 00 15------ AL = 15-------- Copy 15 into AL
MOV BL,[15]--------D1 01 15----- BL = [15]------ Copy RAM[15] into AL

Je ne sais donc pas comment m´y prendre pour effectuer cette traduction. Dois je faire une reconnaissance des expressions, et donc de chaque expression.

De plus le fichier en entrée étant un fichier texte, je ne sais pas comment l´importer, et ensuite l´exploiter au sein de mon programme java que je dois concevoir. Ci dessous, un exemple simple de programme assembleur que je prendrais en entrée et que je dois traduire en langage machine.

CLO //Close unwanted windows.
MOV AL,2 // Copy a 2 into the AL register.
MOV BL,2 // Copy a 2 into the BL register.
ADD AL,BL // Add AL to BL. Answer goes into AL.
END // Program ends

J´espere avoir été clair. Je reviendrais plus souv
ent parce que je vois que il y a des pros ici.

d´accord, ton but c´est d´écrire la fonction assembleur -> code machine.
Il te faut faire plusieurs choses:
-lire le fichier. pour ca, regarde dans l´API java a FileInputStream et a BufferedReader.
Su les I/O, je penses qu´il y a un tutorail de sun.

-parser les lignes: tu dois avoir une grammaire de ton langage qui t´es donné. Le but est d´obtenir une représentation interne du code assembleur.
-transformer cette représentation interne en code machine
-ecrire dans un fichier: pour cela regarde dans l´API java a FileOutputStream et a PrintWriter

c´est moi, où tu as juste répéter son énoncé ?

Le point "difficile" c´est l´assemblage.

En fait, il faudrait avoir l´énoncé précis (y compris le langage assembleur que tu utilise) pour savoir ce que tu doit faire. Mais si c´est juste une traduction d´un code assembleur vers un code machine, sans rien d´autre (par exemple, sans transformation de nom de label ou de variable), alors ce n´est pas très dur, car en accord avec la "grammaire" de ton langage, chaque ligne de code asembleur doit être transformé en 3 ou 4 octets de code machine. Il te suffit donc de lire ligne après ligne ton code assembleur et d´effecuter la traduction qui est une traduction mot à mot.

Par exemple si tu lis dans le fichier d´entrée la ligne :
MOV AL,15
Tu écrit à la suite de ton fichier de sortie les 3 octets suivants: D0 00 15 (en convertissant bien les valeurs hexa, en octets).

Si il faut que tu fasse en plus une conversion de nom de label par exemple, alors la manière la plus simple (mais pas la plus efficace) c´est de le faire en deux étapes, d´apbord tu lis une fois en faisant une liste des label et leur adresse, puis tu recommence en regardant dans ta liste chaque fois que tu vois un label pour le remplacer par sa valeur.

Merci de vos réponses.

Je dois effectivement simplement réaliser ce travail de traduction. Mais comment puisje m´y prendre?

Afin que mon programme reconnaisse "MOV" ou même les fichiers "AL", "BL" ...je dois donc créer des classes qui reconnaissent ces mots clés . Mais je ne connais pas la fonction qui fait ce genre de chose.
Ensuite, une fois ce mot clé reconnu je dois remplacer ce mot clé par sa traduction en binaire. Je ne connais pas non plus la fonction qui puisse executer cela.

Je vais biensur continuer d´y reflechir mais je vous serais tres reconnaissant de me donner vos avis s´ils vous semblent plus pertinent que le mien!

Surtout je me demande comment parcourir tout mon programme en langage assembleur que j´aurais a traduire en langage machine afin de traduire en mot a mot, sachant que le fichier d´entrée est un fichier texte.

Voila mon programme:

public void lire()
{

try
{

String adressedufichier = System.getProperty("user.dir") + "\\Test.txt";

FileReader fr = new FileReader(adressedufichier);
BufferedReader br = new BufferedReader(fr);

String texte = "";
int a=0;
while(a<?)
{
texte = texte + br.readLine() + "\n";
a++;
}
br.close();

//readLine pour lire une ligne
//note: si il n y a rien, la fonction r
etournera la valeur null

System.out.println(texte);
//on affiche le texte

}

Je ne sais donc pas jusqu´ou je dois aller. J´ai e
ssayé : while (br.readline()!="END") car tous les programmes assembleur finissent par end, mais ca ne fonctionne pas. Que dois donc mettre ?

il doit y avoir quelque chose du genre br.eof() non ? (je ne connais pas le java) qui indique que la fin du fichier est atteinte.

il faudrait donc faire while (!br.eof()) (si ça existe).

Mais justement, jepense que tu n´a pas besoin de faire :
texte = texte + br.readLine() + "\n";

mais seulement :
texte = br.readLine();
et tu convertit cette ligne là seulement en code machine (de toute manière le code machine ne dépend pas des autres lignes.

Donc il te faut une fonction qui convertie une ligne (et une seule) de code assembleur en code machine (c´esdt déjà plus simple) et ligne après ligne tu converti la ligne en code machine et tu imprime cette ligne là (ou alors tu l´enregistre dans un fichier texte).