CER SCHMITT Mathieu
Prosit : Sujet inconnu
Objectifs:
-
Savoir le langage adapté au programme
Définitions des mots-clés :
Migration d’application : Passage d'un état existant d'un système d'information ou d'une application
vers une cible définie dans un projet ou un programme.
Code source : Le code source (ou le source) est un ensemble d'instructions écrites dans un langage
de programmation informatique de haut niveau, c'est-à-dire humainement compréhensible,
permettant d'obtenir un programme pour un ordinateur.
Code exécutable : Le code exécutable, c'est la forme qu'a le programme après sa compilation. Les
instructions écrites à l'origine en langage de programmation sont traduites en séquences d'opérations
adaptées au microprocesseur utilisé, et le programme peut s'exécuter sans faire appel à un autre
programme mais directement depuis le système d'exploitation .
Expressions différentes :
Contrôle de séquence :
Syntaxe d’une fonctionnalité :
Langage interprétée : En informatique, un programme écrit en langage interprété est converti en
instructions directement exécutables par la machine au moment de son exécution. Au contraire, un
programme écrit en langage compilé est traduit en instructions lisibles par la machine une fois pour
toutes.
CER SCHMITT Mathieu
Le programme qui traduit le langage interprété est appelé interprète ; il doit être en fonctionnement
sur la machine où l'on veut lancer un programme interprété.
Etudier langages compilés et langages interprétés
Interprète
Définition
En informatique, un interprète (parfois appelé, à tort, « interpréteur » par mauvaise traduction de
l'anglais) est un outil ayant pour tâche d'analyser, de traduire et d'exécuter un programme écrit dans
un langage informatique. De tels langages sont dits langages interprétés.
L'interprète est capable de lire le code source d'un langage sous forme de script, habituellement un
fichier texte, et d'en exécuter les instructions après une analyse syntaxique du contenu.
Généralement ces langages textuels sont appelés des langages de programmation. Cette
interprétation conduit à une exécution d'action ou à un stockage de contenu ordonné par la syntaxe
textuelle.
L'interprétation repose sur l'exécution dynamique du programme par un autre programme
(l'interprète), plutôt que sur sa conversion en un autre langage (par exemple le langage machine) ;
elle évite la séparation du temps de conversion et du temps d'exécution, qui sont simultanés.
On différencie un programme dit script, d'un programme dit compiler :


Un programme script est exécuté à partir du fichier source via un interpréteur de script.
Un programme compilé est exécuté a partir d'un bloc en langage machine issu de la
traduction du fichier source.
Le cycle d'un interprète est le suivant :



lire et analyser une instruction (ou expression) ;
si l'instruction est syntaxiquement correcte, l'exécuter (ou évaluer l'expression) ;
passer à l'instruction suivante.
Ainsi, contrairement au compilateur, l'interprète exécute les instructions du programme (ou en
évalue les expressions), au fur et à mesure de leur lecture pour interprétation. Du fait de cette phase
sans traduction préalable, l'exécution d'un programme interprété est généralement plus lente que le
même programme compilé. La plupart des interprètes n'exécutent plus la chaîne de caractères
représentant le programme, mais une forme interne, telle qu'un arbre syntaxique.
En pratique, il existe une continuité entre interprètes et compilateurs. Même dans les langages
compilés, il subsiste souvent une part interprétée (souvent les formats d'impressions 'FORMAT' de
Fortran, 'printf' de C…, restent interprétés). Réciproquement, la plupart des interprètes utilisent des
représentations internes intermédiaires (arbres syntaxiques abstraits, ou même code octet) et des
CER SCHMITT Mathieu
traitements (analyses lexicale et syntaxique) ressemblant à ceux des compilateurs. Enfin, certaines
implémentations de certains langages (par exemple SBCL pour Common Lisp) sont interactifs comme
un interprète, mais traduisent dès que possible le texte d'un bout de programme en du code
machine directement exécutable par le processeur. Le caractère interprétatif ou compilatoire est
donc propre à une réalisation d'un langage de programmation, et pas au langage lui-même.
L'intérêt des langages interprétés réside principalement dans la facilité de programmation et dans
la portabilité. Les langages interprétés facilitent énormément la mise au point des programmes car
ils évitent la phase de compilation, souvent longue, et limitent les possibilités de bogues. Il est en
général possible d'exécuter des programmes incomplets, ce qui facilite le développement rapide
d'applications ou de prototypes d'applications. Ainsi, le langage BASIC fut le premier langage
interprété à permettre au grand public d'accéder à la programmation, tandis que le premier langage
de programmation moderne interprété est Lisp.
La portabilité permet d'écrire un programme unique, pouvant être exécuté sur diverses plate-formes
sans changements, pourvu qu'il existe un interprète spécifique à chacune des ces plate-formes
matérielles.
Un certain nombre de langages informatiques sont aujourd'hui mis en œuvre au moyen d'une
machine virtuelle applicative. Cette technique est à mi-chemin entre les interprètes tels que décrits
ici et les compilateurs. Elle offre la portabilité des interprètes avec une bonne efficacité. Par exemple,
des portages de Java, Lisp, Scheme, Ocaml, Perl (Parrot), Python, Ruby, Lua, C, etc. sont faites via une
machine virtuelle.
L'interprétation abstraite (inventée par Patrick et Radhia Cousot) est une technique et un modèle
d'analyse statique de programmes qui parcourt, un peu à la manière d'un interprète, le programme
analysé en y remplaçant les valeurs par des abstractions. Par exemple, les valeurs des variables
entières sont abstraites par des intervalles d'entiers, ou des relations algébriques entre variables.
Utilisation
Les langages interprétés trouvent de très nombreuses utilisations :
-
-
dans le domaine éducatif, les langages interprétés permettent de se concentrer sur les
algorithmes et les structures de données, et non sur les particularités de tel ou tel langage.
les calculs scientifiques ne demandant pas de calcul intensif (itérations sur de très grandes
matrices, par exemple) peuvent s'écrire avec profit dans un langage interprété. Ils
permettent d'appeler des algorithmes de calcul performants précompilés. Les systèmes de
calcul symbolique utilisent aussi cette possibilité ;
les interprètes de ligne de commande (désignés par le nom shell dans la terminologie Unix).
Ces interprètes sont capables de comprendre des commandes frappées sur un clavier ou en
provenance d'une autre source. Ils disposent d'une syntaxe spécifique à chaque système
d'exploitation, et permettent de gérer les ressources matérielles d'une machine (disques,
mémoire centrale, entrées/sorties, etc.) ainsi que la communication entre les programmes.
Rexx est le langage de commandes des ordinateurs centralisés d'IBM, tandis que les Bourne
shell, C-shell, Korn shell sont les shells les plus courants sous Unix ; quant au MS-DOS, le plus
rudimentaire des interprètes de ligne de commande, il est propre aux systèmes
d'exploitation de Microsoft. Des langages de programmation comme Perl ou Rexx sont
CER SCHMITT Mathieu
souvent installés pour disposer d'un environnement plus puissant et plus convivial que les
shells d'origine. On conçoit que la compilation traditionnelle présenterait peu d'intérêt pour
des commandes :
o dont chacune est exécutée en moyenne une fois ;
o ou dont la limitation de performance provient de questions d'accès aux fichiers, et
non de calcul ;
o le langage SQL (Standard Query Language) est un langage interprété standardisé qui
permet de mettre à jour ou extraire des informations contenues dans des bases de
données ;
o les navigateurs web reçoivent des instructions symboliques et les exécutent
directement. Les navigateurs courants savent tous interpréter du code HTTP
(HyperText Transfer Protocol) pour les instructions de transfert d'une machine à
l'autre, du code HTML (HyperText Markup Langage) pour les descriptions des pages
web, et du Javascript pour une programmation plus élaborée, offrant la possibilité de
manipuler des variables plus ou moins complexes, des structures de contrôle et de
manipuler les différents objets entrants dans la composition d'une page Web. Ces
pages peuvent être statiques (elles sont écrites une fois pour toutes) ou générées
dynamiquement par le serveur qui produit le code HTML au moment de la requête. Il
peut ainsi adapter la page en fonction du contexte d'exécution. Les langages les plus
couramment utilisés pour la génération dynamique de page Web sont Perl, PHP et
ASP ;
o de nombreux programmes incluent un langage afin d'automatiser certaines actions
ou de créer de nouvelles fonctionnalités. Un des langages les plus utilisés pour cela
est Scheme, une variante de Lisp. Le langage de description XML est aussi fortement
utilisé pour le formatage des données, que ce soit au niveau de l'interface hommemachine, au niveau du transfert de données ou de leur écriture sous forme de
fichiers. Dans ce domaine, on trouve également Perl, Python ou Tcl ;
o le langage PostScript, langage permettant la description de graphiques vectoriels
(propriété de la société Adobe), qui est souvent implémenté dans les imprimantes
graphiques, les tables traçantes et les photocomposeuses ;
o il existe des extensions permettant la programmation rapide d'interfaces graphiques
à l'aide de langages interprétés. Le plus répandu est Tcl/Tk, mais il existe également
Python/Tk, Python/wxWidgets, Perl/wxWidgets Python/Qt ou encore Gambas ;
o dans le monde industriel, de plus en plus de machines sont pilotables par un langage
interprété : les robots industriels, les machines-outils (APT, langage ISO (ou blocs)),
les traceurs de plan, souvent pilotés en PostScript.
Avantages
- Portable
- Rependue
- Facilité de programmation
- Utilisés dans de nombreux OS
Inconvénient
- Code source peu protégé
- Moins puissant que langage compilé
- Plus lent !!
CER SCHMITT Mathieu
Langage compilé
Définition
Un compilateur est un programme informatique qui traduit un langage, le langage source, en un
autre, appelé le langage cible, en préservant la signification du texte source. Ce schéma général
décrit un grand nombre de programmes différents ; et ce que l'on entend par « signification du texte
source » dépend du rôle du compilateur. Lorsque l'on parle de compilateur, on suppose aussi en
général que le langage source est, pour l'application envisagée, de plus haut niveau que le langage
cible, c'est-à-dire qu'il présente un niveau d'abstraction supérieur.
En pratique, un compilateur sert le plus souvent à traduire un code source écrit dans un langage de
programmation en un autre langage, habituellement un langage d'assemblage ou un langage
machine. Le programme en langage machine produit par un compilateur est appelé code objet.
Un programme écrit dans un langage dit « compilé » va être traduit une fois pour toutes par un
programme annexe (le compilateur) afin de générer un nouveau fichier qui sera autonome, c'est-àdire qui n'aura plus besoin d'un programme autre que lui pour s'exécuter (on dit d'ailleurs que ce
fichier est exécutable).
Un programme écrit dans un langage compilé a comme avantage de ne plus avoir besoin, une fois
compilé, de programme annexe pour s'exécuter. De plus, la traduction étant faite une fois pour
toute, il est plus rapide à l'exécution. Toutefois il est moins souple que programme écrit avec un
langage interprété car à chaque modification du fichier source (fichier intelligible par l'homme : celui
qui va être compilé) il faudra recompiler le programme pour que les modifications prennent effet.
D'autre part, un programme compilé a pour avantage de garantir la sécurité du code source. En effet,
un langage interprété, étant directement intelligible (lisible), permet à n'importe qui de connaître les
secrets de fabrication d'un programme et donc de copier le code voire de le modifier. Il y a donc
risque de non-respect des droits d'auteur. D'autre part, certaines applications sécurisées nécessitent
la confidentialité du code pour éviter le piratage (transaction bancaire, paiement en ligne,
communications sécurisées, ...).
Structure d'un compilateur
La tâche principale d'un compilateur est de produire du code objet correct. La plupart des
compilateurs permettent d'optimiser le code (le code objet optimisé s'exécutera plus rapidement, ou
aura une occupation mémoire moindre).
Un compilateur fonctionne par analyse-synthèse, c'est-à-dire qu'au lieu de remplacer chaque
construction du langage source par une suite équivalente de constructions du langage cible, il
CER SCHMITT Mathieu
commence par analyser le texte source pour en construire une représentation intermédiaire qu'il
traduit à son tour en langage cible.
Il est donc naturel de séparer — au moins conceptuellement, mais aussi en pratique — le
compilateur en une partie avant (ou frontale), parfois appelée « souche », qui lit le texte source et
produit la représentation intermédiaire, et une partie arrière (ou finale), qui parcourt cette
représentation pour produire le texte cible. Dans un compilateur idéal, la partie avant est
indépendante du langage cible, tandis que la partie arrière est indépendante du langage source.
Certains compilateurs effectuent de plus sur la forme intermédiaire des traitements substantiels, que
l'on peut regrouper en une partie centrale, indépendante à la fois du langage source et de la machine
cible. On peut ainsi écrire des compilateurs pour toute une gamme de langages et d'architectures en
partageant la partie centrale, à laquelle on attache une partie avant par langage et une partie arrière
par architecture.
Les étapes de la compilation incluent :
-
le découpage du programme en lexèmes (analyse lexicale) ;
la vérification de la correction de la syntaxe du programme (analyse syntaxique) ;
l'analyse des structures de données (analyse sémantique) ;
la transformation du code source en code intermédiaire ;
l'application de techniques d'optimisation sur le code intermédiaire ;
l'allocation de registres et la traduction du code intermédiaire en code objet, avec
éventuellement l'insertion de données de débogage et d'analyse de l'exécution ;
et enfin l'édition des liens.
Ces différentes étapes expliquent que les compilateurs fassent toujours l'objet de recherches,
particulièrement dans le domaine de l'optimisation du code produit.
La plupart (mais pas tous) des compilateurs traduisent un fichier source d'un programme écrit dans
un langage de programmation en un fichier objet (ou un exécutable, ou un fichier en assembleur, ou
même en un autre langage).
Une implémentation (réalisation concrète) d'un langage de programmation peut être interprétée ou
compilée. C'est cette réalisation qui est un compilateur ou un interpréteur, et un langage de
programmation (spécification plus ou moins théorique et formalisée de sa syntaxe et de sa
sémantique) peut avoir une implémentation compilée, et une autre interprétée.
Avantages
- Très puissant
- Code source protégé
- Pas besoin de programme annexe une
fois la compilation réalisé
Inconvénient
- Peu portable
- Compilation lourde
- Langage plus complexe
- Compilateur bugé
- A chaque modification, recompilation
nécessaire
CER SCHMITT Mathieu
Etudier langages procéduraux et langages orientés objet
Langages procéduraux
Définition
Les langages procéduraux, comme leur nom l’indique, sont à base de procédures. Une procédure est
une portion de programme écrit en langage de haut niveau qui accomplit une tâche spécifique
nécessaire au programme. Certaines de ces procédures sont intrinsèques, elles sont intégrées au
langage, il suffit de les appeler en nommant la procédure et son argument, par exemple COS(X) va
calculer le cosinus du nombre contenu dans la variable (X). D'autres procédures sont dites
extrinsèques parce qu'elles sont écrites par le programmeur. Ces langages procéduraux peuvent être
aussi bien des compilateurs (Fortran, Cobol, Algol, Pascal et C) que des interpréteurs (Basic et APL).
La programmation procédurale est souvent un meilleur choix qu'une simple programmation
séquentielle ou programmation non-structurée. Avantages possibles :
-
-
La possibilité de réutiliser le même code à différents emplacements dans le programme sans
avoir à le retaper ;
Une façon plus simple de suivre l'évolution du programme. La programmation procédurale
permet de se passer d'instructions telles que "GOTO" et "JUMP" évitant ainsi bien souvent de
se retrouver avec un programme compliqué qui part dans toutes les directions (appelé
souvent « programmation spaghetti ») ;
La création d'un code plus modulaire et structuré.
Les langages de programmation procédurale facilitent la tâche du programmeur en permettant de
privilégier une approche procédurale. Le plus vieil exemple de ce type de langage est ALGOL.
D'autres exemples sont Fortran, PL/I, Modula-2 et Ada. À noter que la liste qui suit inclut certains
langages qui ne sont pas exclusivement procéduraux, tel que Java, qui a été spécialement développé
pour la programmation orientée-objet.
















Ada ;
BASIC ;
C;
C++ ;
C# ;
ColdFusion ;
COBOL ;
Component Pascal ;
Delphi ;
ECMAScript a.k.a. JavaScript, DMDScript, ActionScript, JScript ;
Forth ;
Fortran ;
FPC Pascal ;
Mathematica ;
Modula-2 ;
Oberon et Oberon-2 ;
CER SCHMITT Mathieu








Pascal ;
Perl ;
PL/C ;
PL/I ;
Rapira ;
VBScript ;
Visual Basic;
W-Langage.
Les langages déclaratifs
Les langages déclaratifs sont des langages qui ne nécessitent pas la programmation de procédures
exactes. Il suffit pour le programmeur de déclarer la tâche qu’il veut faire exécuter à l’ordinateur.
Parmi les langages déclaratifs les plus connus, notons LISP, Logo et Prolog. En Lisp et en Logo, on
programme des listes qui déclarent les relations qui existent entre certaines valeurs symboliques. En
Prolog, on produit des ensembles de faits et de règles à propos de connaissances ; le programme tire
des inférences sur ce qui est vrai et ce qui est faux.
Les langages orientés-objets
Les langages orientés-objets sont des langages non procéduraux dans lesquels les éléments du
programme sont considérés comme des objets qui peuvent s'échanger des messages. Programmer
consiste donc à créer des objets et à passer des messages entre ceux-ci. Nommons parmi les
langages orientés-objets les plus connus : Smalltalk et C++. C'est actuellement un type de
programmation très en vogue dans le milieu de l'informatique.
Les enjeux sont de deux natures :
1. Le choix d'un langage pour développer un logiciel est très important.
En effet, ce langage doit être adapté au problème. Il est donc intéressant de le choisir avec soin avant
de commencer tout codage, d'autant plus qu'il existe énormément de langages de programmation.
L'avantage de programmer avec un langage orienté objets est le découpage du problème en objets
qui est une représentation proche de la pensée humaine. De plus, les concepts orientés objets
permettent d'envisager la réutilisation du code avec plus de facilité.
2. Un logiciel, un compilateur ou interpréteur dans notre cas, peut être considéré comme une boîte
noire, livré par l'éditeur, à laquelle on fournit des informations (du code source) et en retour renvoie
des résultats (code objet, code machine ou exécution du programme). L'accès au code-source du
logiciel par l'utilisateur et même sa modification permettent :
CER SCHMITT Mathieu
_ De vérifier la qualité du logiciel ;
_ De réutiliser complètement ou en partie le logiciel et le code source ;
_ De corriger et/ou étendre les capacités du logiciel ;
_ D’adapter le logiciel à son système informatique ;
_ De continuer à maintenir ce logiciel même si l'éditeur a arrêté son support.
Comparer les différents langages
Comparons les différents langages :
Les critères de comparaison sont très subjectifs car sont liés à l'expérience des programmeurs, des
chefs de projet, ...
Lisibilité
_ Abstraction (dans les données : record/struct/classes/... et dans les traitements :
fonctions/procédures/modules/classes/...) ;
_ Simplicité (peu de choses à connaître, moins de risques d'erreurs, programmes plus faciles à
comprendre, moins de risques de ne connaître qu'un sous-ensemble du langage) ;
_ Orthogonalité (moins d'exceptions, donc plus simple tout en offrant une large combinaison de
choix) ;
_ Expressivité du langage (code plus compacte et complexe est-il préférable à code plus dilué ?
Comparez la lisibilité de Pascal et C par exemple) ;
_ Style de programmation (apparence des commentaires, longueur des identifiants, ...).
Facilité d'écriture
_ Abstraction et simplicité, comme la lisibilité ;
_ Expressivité, comme la lisibilité ;
_ Modularité et les outils de modularisation, support pour les environnements de développement
intégrés.
CER SCHMITT Mathieu
Sécurité
_ Protection contre les erreurs bêtes (fautes de frappe, ...) ;
_ Protection contre les erreurs de typage ;
_ Gestion des exceptions (_Exceptions Handling_)
_ Noms non ambigus (alias).
Coût
_ Temps de développement,
_ Temps de traduction du langage de programmation (haut niveau) dans un autre (plus bas niveau),
i.e. compilation,
_ Qualité d'implémentation (optimisation),
_ Portabilité des programmes,
_ ...
Voici une proposition d'échelle de pondération tableau pour en simplifier sa lecture.
CER SCHMITT Mathieu
Tableau comparatif de langage (POO)
Spécificité des langages
CER SCHMITT Mathieu
Spécificité des langages (POO)
CER SCHMITT Mathieu
Etudier les langages spécifiques
Limiter pour optimiser
Les langages de programmation utilisés au quotidien par les développeurs sont le plus souvent
d'ordre généraliste : ils peuvent servir à résoudre plusieurs types de problèmes, à l'aide de plusieurs
approches différentes au besoin. PHP, Java, C#, JavaScript et autres sont ainsi des langages
généralistes.
Au contraire, les langages spécifiques, dits également "langages dédiés", ou domain-specific
languages (DSL), ont été conçus pour répondre à un type donné de problème, ou à un domaine
d'application spécifique. Langages généralistes et langages dédiés cohabitent depuis le début de
l'informatique, mais si ces derniers sont restés de fait moins populaires que leurs cousins à usages
multiples, ils profitent d'un regain d'intérêt auprès des développeurs désireux de maîtriser leurs
outils ou d'améliorer leurs tâches quotidiennes. Les premiers langages généralistes connus, comme
Lisp, Fortran ou Cobol, sont en réalité des évolutions généralistes de langages originellement dédiés
à
un
problème,
un
domaine,
une
machine...
Les DSL sont rendus nécessaires par le besoin de disposer d'un moyen réellement optimisé de traiter
un problème. Un langage généraliste aura tendance à proposer des fonctionnalités qui traiteront
certes correctement le problème, mais pas de la manière la plus optimale. Un langage dédié, parce
qu'il est conçu à seule fin de traiter un problème ou domaine précis, pourra se délester des
lourdeurs
inhérentes
à
une
approche
généraliste.
Ainsi, les DSL présentent de nombreux avantages : ils utilisent les idiomes et le niveau d'abstraction
du domaine ciblé, et donc sont utilisables par des spécialistes ; ils sont légers, donc facilement
maintenables, portables et réutilisables ; ils sont le plus souvent très documentés, cohérents et
fiables
;
ils
sont
optimisés
pour
le
domaine.
Cependant, utiliser un DSL a un coût : il nécessite de concevoir, implémenter et maintenir son propre
langage, d'éduquer ses utilisateurs, et de définir précisément son champ d'utilisation.
Il existe plusieurs centaines de DSL, la plupart non publics. Certains cependant ont une telle
importance qu'ils se confondent souvent avec le domaine qu'ils exploitent : SQL pour les bases de
données, HTML pour les pages Web, BNF pour définir la syntaxe des langages, Make pour la
compilation d'application... Un DSL n'a donc pas forcément besoin d'être "compilé" dans le sens
binaire du terme, mais doit disposer au minimum d'un interpréteur. Il présente une syntaxe limitée
et propre à accomplir de la manière la plus claire possible les traitements nécessaires au domaine.
CER SCHMITT Mathieu
Outre l'interprétation ou la compilation, les DSL peuvent se retrouver sous forme de langages
embarqués au sein d'un autre, ou de bibliothèques de fonctions dédiées. La syntaxe du langage
hôte sert alors à recréer les idiomes du domaine. L'avantage de cette approche est de ne pas avoir à
développer d'interpréteur/compilateur, mais d'utiliser celui du langage hôte. Le DSL y perd
cependant la spécificité de ses mécanismes, et l'optimisation qui en découle.
Enfin, il reste possible, pour les besoins avancés, d'inclure le DSL au langage hôte sous la forme de
fonctionnalités construites dans le langage par le biais d'un préprocesseur, voire d'inclure cette
phase de construction au sein même du compilateur, reconstruisant ainsi le langage hôte avec en
plus des fonctionnalités voulues. L'interpréteur Tcl, étendu pour de nombreux domaines, en reste le
principal exemple.
Etudier les différents niveaux de langage (génération)
Etude de cas
CER SCHMITT Mathieu
Langage de haut niveau
Un langage de haut niveau en informatique est un langage de programmation qui permet au
programmeur de s'abstraire de détails inhérents au fonctionnement de la machine, ceux-ci étant pris
en compte lors de la compilation. Il permet de manipuler des concepts bien plus élaborés, mais
empêche la gestion de certains de ces détails. Ex : C, java, ada,…
Langage Assembleur
Le langage assembleur est un langage de programmation permettant à un humain d’écrire des
algorithmes en utilisant le jeu d’instructions spécifique à une machine donnée (un processeur)
• Le langage assembleur permet au programmeur de prendre du recul par rapport au
langage objet et ainsi de se consacrer à la programmation (apparition dans les années 1950)
• La programmation en assembleur est beaucoup plus aisée pour le programmeur que
l’écriture en langage machine; cependant, elle est plus complexe que la programmation à l’aide d’un
langage de haut niveau
• La programmation directe en langage assembleur permet d’obtenir un code très compact,
rapide, et nécessitant un minimum d’espace mémoire
• La transformation d’un programme assembleur en langage machine s’appelle
l’assemblage, elle est réalisée par un assembleur (l’opération inverse s’appelle elle le
désassemblage)
Langage machine
Le langage machine est le niveau de programmation le plus bas, ayant une correspondance très
directe avec le langage assembleur qui est plus accessible pour le programmeur humain
• Les instructions y sont représentées sous forme de chaînes binaires (constituées de bits
(binary digit) pouvant prendre 0 ou 1 comme valeur)
• Chaque instruction a une adresse qui permet de la repérer en mémoire (pour pouvoir y
retourner)
• Une instruction se décompose en:
– un code d’opération (par exemple sur 8 bits, permettant un jeu de
256 opérations différentes)
CER SCHMITT Mathieu
– les opérandes sur lesquelles portent l’opération (registres,
emplacements mémoire, valeurs immédiates)
Etudier lexique, grammaire, sémantique des langages
Sémantique des langages
L’analyse sémantique a deux fonctions:
– reconnaître les objets manipulés: type, durée de vie, taille
– vérifier la cohérence de l’utilisation des objets reconnus:
• erreurs de déclarations, ex:
– déclarations multiples d’une même variable dans un même bloc
– absence de déclaration
• erreurs de typage, ex:
– retour d’une valeur d’un mauvais type dans une fonction
– transmission de paramètres de mauvais types
– utilisation d’un réel comme indice de tableau
– expressions mal formées
– etc.