La lecture en ligne est gratuite
Le téléchargement nécessite un accès à la bibliothèque YouScribe
Tout savoir sur nos offres

Partagez cette publication

Publications similaires

Vous aimerez aussi

42 ? Java/src/fr/upmc/ilp/ilp1/runtime/Invokable.java
43 ?c/fr/upmc/ilp/ilp1/runtime/LexicalEnvironment.java
44 ? Java/src/fr/upmc/ilp/ilp1/runtime/PrintStuff.java
45 ?c/fr/upmc/ilp/ilp1/eval/EAST.java
Code ILP1 45 ? Java/src/fr/upmc/ilp/ilp1/eval/EASTConstant.java
46 ?c/fr/upmc/ilp/ilp1/eval/EASTException.java
46 ? Java/src/fr/upmc/ilp/ilp1/eval/EASTFactory.java
Christian.Queinnec@lip6.fr
47 ?c/fr/upmc/ilp/ilp1/eval/EASTFileTest.java
49 ? Java/src/fr/upmc/ilp/ilp1/eval/EASTParser.java
28 septembre 2011
53 ?c/fr/upmc/ilp/ilp1/eval/EASTPrimitiveTest.java
54 ? Java/src/fr/upmc/ilp/ilp1/eval/EASTTest.java
58 ?c/fr/upmc/ilp/ilp1/eval/EASTalternative.java
Ces chiers sont diffusés pour l’enseignement ILP (Implantation d’un langage de programmation) dis- 59 ? Java/src/fr/upmc/ilp/ilp1/eval/EASTblocUnaire.java
pensé depuis l’automne 2004 à l’UPMC (Université Pierre et Marie Curie). Ces chiers sont diffusés selon 60 ?c/fr/upmc/ilp/ilp1/eval/EASTbooleen.java
les termes de la GPL (Gnu Public Licence). Pour les transparents du cours, la bande son et les autres 60 ? Java/srchaine.java
documents associés, consulter le site http ://www-master.ufr-info-p6.jussieu.fr/site-annuel-courant/ilp 61 ?entier.java
61 ? Java/src/fr/upmc/ilp/ilp1/eval/EAST ottant.java
62 ?invocation.java
Table des matières 62 ? Java/src/fr/upmc/ilp/ilp1/eval/EASTinvocationPrimitive.java
63 ?operation.java
4 ? LISEZ.MOI 63 ? Java/sroperationBinaire.java
5 ? Grammars/Make le 64 ?operationUnair
6 ? Grammars/grammar1.rnc 65 ? Java/srsequence.java
7 ? Java/jars/JARS.readme 65 ?c/fr/upmc/ilp/ilp1/eval/EASTvariable.java
8 ? Java/src/fr/upmc/ilp/ilp1/interfaces/IAST.java 66 ? Java/src/fr/upmc/ilp/ilp1/eval/IASTEvaluable.java
8 ?alternative.java 66 ?c/fr/upmc/ilp/ilp1/eval/IEASTFactory.java
9 ? Java/srfaces/IASTbinaryOperation.java 67 ? Java/src/fr/upmc/ilp/ilp1/cgen/CgenEnvironment.java
9 ?faces/IASTboolean.java 69 ?c/fr/upmc/ilp/ilp1/cgen/CgenLexicalEnvironment.java
9 ? Java/srfaces/IASTconstant.java 70 ? Java/src/fr/upmc/ilp/ilp1/cgen/CgenerationException.java
9 ?faces/IAST oat.java 70 ?c/fr/upmc/ilp/ilp1/cgen/Cgenerator.java
9 ? Java/src/fr/upmc/ilp/ilp1/interinteger.java 74 ? Java/src/fr/upmc/ilp/ilp1/cgen/CgeneratorTest.java
9 ?faces/IASTinvocation.java 76 ?c/fr/upmc/ilp/ilp1/cgen/ICgenEnvironment.java
10 ? Java/sroperation.java 77 ? Java/src/fr/upmc/ilp/ilp1/cgen/ICgenLexicalEnvironment.java
10 ?sequence.java 77 ?c/fr/upmc/ilp/ilp1/CoverageTest.java
11 ? Java/srfaces/IASTstring.java 78 ? Java/src/fr/upmc/ilp/ilp1/JDependT
11 ?faces/IASTunaryBlock.java 78 ?c/fr/upmc/ilp/ilp1/Process.java
11 ? Java/src/fr/upmc/ilp/ilp1/interfaces/IASTunaryOperation.java 80 ? Java/srocessTest.java
11 ?faces/IASTvariable.java 80 ?c/fr/upmc/ilp/ilp1/WholeTestSuite.java
11 ? Java/src/fr/upmc/ilp/ilp1/fromxml/AST.java 81 ? Java/src/fr/upmc/ilp/tool/AbstractEnvironment.java
12 ?omxml/ASTException.java 81 ?c/fr/upmc/ilp/tool/AbstractProcess.java
12 ? Java/sromxml/ASTParser.java 84 ? Java/srocessTest.java
15 ?omxml/ASTParserTest.java 89 ?estTest.java
20 ? Java/sromxml/ASTalternative.java 90 ? Java/src/fr/upmc/ilp/tool/CStuff.java
21 ?c/fr/upmc/ilp/ilp1/fromxml/ASTblocUnaire.java 90 ?fTest.java
22 ? Java/sromxml/ASTbooleen.java 91 ? Java/src/fr/upmc/ilp/tool/File.java
22 ?omxml/ASTchaine.java 92 ?c/fr/upmc/ilp/tool/FileTool.java
22 ? Java/srentier.java 93 ? Java/sroolTest.java
23 ?omxml/AST ottant.java 94 ?c/fr/upmc/ilp/tool/Finder.java
23 ? Java/src/fr/upmc/ilp/ilp1/fromxml/ASTfromXML.java 95 ? Java/src/fr/upmc/ilp/tool/FinderTest.java
24 ?omxml/ASTinvocation.java 96 ?c/fr/upmc/ilp/tool/IContent.java
24 ? Java/srinvocationPrimitive.java 97 ? Java/src/fr/upmc/ilp/tool/IFinder.java
25 ?operation.java 97 ?c/fr/upmc/ilp/tool/IProcess.java
25 ? Java/sromxml/ASToperationBinaire.java 98 ? Java/srocessListener.java
26 ?c/fr/upmc/ilp/ilp1/froperationUnair 99 ?c/fr/upmc/ilp/tool/Parameterized.java
26 ? Java/srsequence.java 100 ? Java/src/fr/upmc/ilp/tool/ProgramCaller.java
27 ?omxml/ASTvariable.java 103 ?ogramCallerTest.java
27 ? Java/sromxml/Main.java 105 ? Java/src/fr/upmc/ilp/tool/ToolTestSuite.java
28 ?omxml/MainTest.java 105 ?c/fr/upmc/ilp/annotation/ILPexpression.java
29 ? Java/src/fr/upmc/ilp/ilp1/frestSuite.java 106 ? Java/src/fr/upmc/ilp/annotation/ILPforParsing.java
30 ?c/fr/upmc/ilp/ilp1/runtime/AbstractInvokableImpl.java 106 ?c/fr/upmc/ilp/annotation/ILPvariable.java
30 ? Java/src/fr/upmc/ilp/ilp1/runtime/Common.java 107 ? Java/src/fr/upmc/ilp/annotation/OrNull.java
33 ?c/fr/upmc/ilp/ilp1/runtime/CommonPlus.java 107 ? C/C.readme
40 ? Java/src/fr/upmc/ilp/ilp1/runtime/ConstantsStuff.java 107 ? C/Make le
41 ?c/fr/upmc/ilp/ilp1/runtime/EmptyLexicalEnvironment.java 108 ? C/compileThenRun.sh
42 ? Java/src/fr/upmc/ilp/ilp1/runtime/EvaluationException.java 111 ? C/ilp.c
42 ?c/fr/upmc/ilp/ilp1/runtime/ICommon.java 115 ? C/ilp.h
42 ? Java/src/fr/upmc/ilp/ilp1/runtime/ILexicalEnvironment.java 118 ? C/ilpAlloc.c
1 2118 ? C/ilpAlloc.h LISEZ.MOI
118 ? C/ilpBasicError.c
119 ?or.h
1 Ces fichiers sont diffusés pour l’enseignement ILP (Implantation
119 ? C/ilpException.c d’un langage de programmation) dispensé depuis l’automne 2004 à l’UPMC
120 ? C/ilpException.h (Université Pierre et Marie Curie). Ces fichiers sont diffusés selon
120 ? C/templateTest.c les termes de la GPL (Gnu Public Licence). Pour les transparents du
cours, la bande son et les autres documents associés, consulter le
6 site http://www-master.ufr-info-p6.jussieu.fr/site-annuel-courant/ilp
Adressez-moi toutes vos remarques concernant ce cours ou ces fichiers
avec un courriel dont le titre contient la chaîne « ILP » ou, mieux,
postez-les sur le forum associé au cours.
11
Quelques détails sur ILP
=======================
Quelques répertoires contiennent de sommaires documentations dans des
16 fichiers *.readme ou LISEZ.MOI. C’est le cas pour
Compiler/C/C.readme
Compiler/Java/jars/JARS.readme
21 Les Makefile sont également d’importantes sources d’information.
Installation
============
26 Si vous lisez ce fichier c’est probablement que vous avez décompressé
le fichier ILP-uneCertaineDate.tgz. Assurez vous que les répertoires
Compiler/, PlugIns/ etc. sont bien juste en dessous de votre espace de
travail pour Eclipse (usuellement ~/workspace/). Le TME1 indique la
marche à suivre pour configurer votre Eclipse.
31
Demandez l’importation (menu File) de projets existant dans l’espace
de travail (catégorie General) passez à la suite avec Next et
sélectionnez alors le répertoire correspondant à l’espace de travail.
Eclipse s’aperçoit alors que des projets existent déjà et tentera de
36 les récupérer tels quels.
Une fois ceci fait, pour tester que tout va bien, lancer la classe
fr.upmc.ilp.ilp1.WholeTestSuite (menu contextuel run as "JUnit Test"):
tout doit passer au vert!
41
Greffon ILP
===========
46 Depuis 2006, ILP a introduit un nouveau greffon à incorporer à Eclipse
(au moins 3.2), facilitant quelques opérations. Ce greffon introduit
quelques opérations contextuelles dans l’explorateur de projet. Voici,
par type de fichiers, les opérations principales que l’on peut
obtenir (dans le sous-menu ILP):
51
Sur un fichier .rnc (une grammaire compacte d’ILP)
- conversion en .rng
Sur un fichier .rng (une grammaire (en XML) pour ILP)
- positionnement comme grammaire ILP par défaut
56 Sur un fichier .xml (un programme ILP)
- validation vis-à-vis d’une grammaire ILP choisie dynamiquement
- validation vis-à-vis de la grammaire ILP par défaut
(il existe maintenant sous Eclipse 3.3, un menu contextuel "Validate"
qui ne vérifie que la conformité syntaxique vis-à-vis d’XML).
61 Sur un répertoire (de grammaires .rng)
- positionnement comme répertoire des grammaires par défaut
La grammaire par défaut et le répertoire des grammaires par défaut ne
sont pas conservés entre deux sessions.
66
Le greffon est susceptible d’évoluer, abonnez-vous au site de mise à jour
en http://www.master.info.upmc.fr/2011/Ext/queinnec/ILP/
ce qui va aussi servir à l’installer. Dans le Menu Help, cherchez
Software Updates, Find and Install, Search for new features to install,
71 new Remote Site. Remplissez le formulaire en indiquant qu’ILP est à l’url
http://www.master.info.upmc.fr/2011/Ext/queinnec/ILP/, OK
puis Finish. Eclipse cherche alors le greffon...
Autres greffons
76 ===============
D’autres greffons sont utiles (ou intéressants) mais on peut s’en
passer, je tenterai toutefois de les faire inclure dans l’installation
3 4à l’ARI. Ce sont: grammar5.rnc \
81 grammar6.rnc
Checkstyle 46
http://eclipse-cs.sourceforge.net/ # Créer les équivalents XML des schémas RelaxNG compacts:
Jdepend pour eclipse
http://andrei.gmxhome.de/eclipse/ create.rng.files : ${GRAMMARS:.rnc=.rng}
86 PMD pour Eclipse
http://pmd.sf.net/eclipse 51 # Creer les équivalents XSD des schémas RelaxNG compacts:
FindBugs
http://findbugs.cs.umd.edu/eclipse create.xsd.files : ${GRAMMARS:.rnc=.xsd}
91 Depuis Eclipse Helios, on peut installer ces greffons grâce au menu # Les grammaires s’incluent ce qui cree des dependances:
Help puis Eclipse Market. Chercher alors le greffon par son nom et 56 grammar2.rng : grammar1.rng
l’installer. grammar3.rng : grammar2.rng
grammar4.rng : grammar3.rng
Emacs grammar5.rng : grammar4.rng
96 ===== grammar6.rng : grammar4.rng
61
Le paquetage nxml est réputé. Il se trouve en # Valider les exemples de programmes qui sont en Samples/
http://www.thaiopensource.com/download/nxml-mode-20041004.tar.gz # Verifier que les grammaires sont bien incluses: tout ce que reconnait
mais une copie est dans le répertoire ELISP/ ainsi qu’un mode # grammar1 doit etre reconnu par grammar2, etc.
101 pour éditer des schémas RelaxNG facilement. On peut aussi demander à
Eclipse de plutôt lancer Emacs sur ces fichiers. 66 validate.xml.files : ${GRAMMARS:.rnc=.rng}
for i in 6 5 4 3 2 1 ; do \
Divers for p in Samples/?*-[1-$$i].xml ; do \
====== echo Validating $$p with grammar$$i ; \
106 ${JAVA} -jar ${JING} grammar$$i.rng $$p ; \
Depuis la 3.2, Eclipse dispose d’un éditeur structurel de XML (suffixe 71 done ; done
.xml) ainsi qu’un éditeur de grammaires XMLSchema (suffixe .xsd).
Mon Eclipse est réglé, depuis cette année, sur UTF-8, La plupart des Grammars/grammar1.rnc
111 fichiers *.java sont dans ce mode mais d’autres sont restés en Latin1
(iso-8859-1 ou -15). C’est un mal qui affecte le monde entier et qui
ne sera surmonté qu’avec le temps. # Première version du langage étudié: ILP1 pour « Innocent Langage
# Parachuté. » Il sera complété dans les cours qui suivent.
3
Grammars/Make le start = programme1
programme1 = element programme1 {
1 work : create.rng.files \ instructions
validate.xml.files 8 }
clean :: cleanMakefile
-rm -f grammar*.rng instructions = instruction +
6 # Regenerer toutes les grammaires possibles. # Ce langage est un langage d’instructions, assez réduit pour
all : 13 # l’instant. Voici les instructions possibles:
for g in *.rnc ; do make $${g%c}g ; done
instruction =
# 2007sep06: trang ne fonctionne pas avec le java d’Ubuntu (gij)! De alternative
11 # plus, le code de trang n’est pas generique (a ne pas recompiler donc). | sequence
18 | blocUnaire
JAVA = java | expression
TRANG = ../Java/jars/trang.jar
JING = ../Java/jars/jing.jar # Le si-alors-sinon. L’alternant est facultatif car c’est un langage
16 #CODING = iso-8859-15 # d’instructions.
CODING = utf-8 23
alternative = element alternative {
.SUFFIXES: .rnc .rng .xsd .dtd element condition { expression },
.rnc.rng : element consequence { instructions },
21 ${JAVA} -jar ${TRANG} \ element alternant { instructions } ?
-i encoding=${CODING} \ 28 }
-o encoding=${CODING} \
$*.rnc $*.rng # La séquence qui permet de regrouper plusieurs instructions en une seule.
.rnc.xsd : # Il est obligatoire qu’il y ait au moins une instruction dans la séquence.
26 ${JAVA} -jar ${TRANG} \
-i encoding=${CODING} \ 33 sequence = element sequence {
-o encoding=${CODING} \ instructions
$*.rnc $*.xsd }
.rnc.dtd :
31 ${JAVA} -jar ${TRANG} \ # Un bloc local unaire. C’est, pour l’instant, la seule construction
-i encoding=${CODING} \ 38 # permettant d’introduire une variable localement. Elle sera bientôt remplacée
-o encoding=${CODING} \ # par une construction permettant d’introduire plusieurs variables
$*.rnc $*.dtd # locales en meme temps.
36 # NOTA: Valider un document XML d.xml avec un schéma f.rng et jing ainsi: blocUnaire = element blocUnaire {
# ${JAVA} -jar ${JING} f.rng d.xml 43 variable,
element valeur { expression },
GRAMMARS = \ element corps { instructions }
grammar1.rnc \ }
41 grammar2.rnc \
grammar3.rnc \ 48 # Comme en C, une expression est une instruction dont la valeur est
grammar4.rnc \ # ignorée. Il n’y a pas d’expression parenthésée car ce n’est qu’une
5 6# fioriture syntaxique. Les expressions sont: jcommander-1.18
expression = 12 Les bibliothèques Junit (3 et 4) à utiliser sont celles fournies par Eclipse.
53 constante
| variable JCommander est une bibliothèque pour analyser les options de la ligne
| operation de commander. Elle n’est utilisée que pour des tests.
| invocationPrimitive
17 Les documentations (Javadoc) de jing et trang sont dans le .zip de
58 # Une variable n’est caractérisée que par son nom. Les variables dont même nom. Il faut indiquer à Eclipse où elles sont pour l’aide
# les noms comportent la séquence ilp ou ILP sont réservés et ne contextuelle.
# peuvent être utilisés par les programmeurs.
# FUTUR: restreindre plus les noms de variables aux seuls caracteres normaux! Les autres bibliothèques sont les suivantes
22 hansel une bibliothèque pour mesurer les taux de couverture de test
63 variable = element variable { bcel une bibliothèque d’instrumentation de code octet utilisée
attribute nom { xsd:Name - ( xsd:Name { pattern = "(ilp|ILP)" } ) }, par hansel
empty easymock une bibliothèque pour aider aux tests.
}
Java/src/fr/upmc/ilp/ilp1/interfaces/IAST.java68 # L’invocation d’une fonction primitive. Une fonction primitive est
# procurée par l’implantation et ne peut (usuellement) être définie
# par l’utilisateur. Les fonctions primitives sont, pour être package fr.upmc.ilp.ilp1.interfaces;
# utilisables, prédéfinies. Une fonction primitive n’est caractérisée
# que par son nom (éventuellement masquable).
/** Interface des arbres de syntaxe abstraite.
73
4 *
invocationPrimitive = element invocationPrimitive { * Les arbres de syntaxe abstraite (AST) ne sont utilisés que via
attribute fonction { xsd:Name }, * cette interface ou, plus exactement, via une de ses
expression *
* sous-interfaces. Cette interface ressemble un peu à celle du DOM
}
* (Document Object Model) sauf qu’elle est beaucoup plus légère: elle
78
9 * est plus typée mais elle ne permet que de descendre dans les AST.
# Les opérations sont en fait des sortes d’invocations à des fonctions *
# primitives sauf que ces fonctions sont implantées par le matériel
* La raison d’être de cette interface est qu’elle sert de point de
# par des instructions particulières. On ne distingue que les
* rencontre entre les analyseurs syntaxiques qui doivent produire des
# opérations unaires et binaires (les plus usuelles):
* IAST qui seront ainsi manipulables par les premières passes de
83
14 * l’interprète ou du compilateur.
operation = */
operationUnaire
| operationBinaire
public interface IAST {
88 operationUnaire = element operationUnaire {
19 /** Décrit l’AST sous forme d’une chaîne imprimable.
attribute operateur { "-" | "!" },
*element operande { expression }
* En fait, c’était pour mettre quelque chose (ce qui n’est pas}
* obligatoire) ! Cette méthode vient avec toute implantation
operationBinaire = element operationBinaire {
* puisque l’objet implantant hérite d’Object qui définit
93 element operandeGauche { expression },
24 * toString()! Par contre, la mentionner ici rend sa définition
attribute operateur {
* explicite obligatoire dans les classes qui implantent IAST."+" | "-" | "*" | "/" | "%" | # arithmétiques
*/"|" | "&" | "^" | # booléens
String toString ();
"<" | "<=" | "==" | ">=" | ">" | "<>" | "!=" # comparaisons
98 },
29 // FUTURE ajoute-t-on toXML() pour sérialiser les IAST ?
element operandeDroit { expression }
}
}
# Les constantes sont les données qui peuvent apparaître dans les
103 # programmes sous forme textuelle (ou littérale comme l’on dit Java/src/fr/upmc/ilp/ilp1/interfaces/IASTalternative.java
# souvent). Ici l’on trouve toutes les constantes usuelles à part les
# caractères:
package fr.upmc.ilp.ilp1.interfaces;
constante =
108 element entier { 3 import fr.upmc.ilp.annotation.OrNull;
attribute valeur { xsd:integer },
empty } /** Décrit une alternative (si-alors-sinon).
| element flottant { *
attribute valeur { xsd:float }, * Une alternative comporte une condition (booléenne), une conséquence
113 empty } 8 * (une expression quelconque) ainsi, éventuellement, qu’un alternant
| element chaine { text } * (une expression aussi). La méthode isTernary() permet de distinguer
| element booleen { * entre ces deux cas.
attribute valeur { "true" | "false" }, */
empty }
13 public interface IASTalternative extends IAST {
Java/jars/JARS.readme /** Renvoie la condition. */
IAST getCondition ();
18 /** Renvoie la conséquence. */Ce répertoire contient des archives .jar contenant les classes et ressources
IAST getConsequent ();2 utiles pour les bibliothèques telles que jing ou trang. Les paquets .tgz
ou .zip contiennent les distributions originales et notamment la documentation
des interfaces (API). /** Renvoie l’alternant si présent ou null. */
@OrNull IAST getAlternant ();
23Les bibliothèques vraiment importantes sont
/** Indique si l’alternative est ternaire (qu’elle a un alternant). */7 jing.jar
trang.jar boolean isTernary ();
xmlunit1.3.jar }
7 8Java/src/fr/upmc/ilp/ilp1/interfaces/IASTbinaryOperation.java package fr.upmc.ilp.ilp1.interfaces;
import fr.upmc.ilp.annotation.OrNull;
package fr.upmc.ilp.ilp1.interfaces;
5
/** Décrit une invocation de fonction. La fonction peut être calculée
3 /** Interface décrivant les opérations binaires.
* ou pas, c’est néanmoins un AST. Si le nom n’est pas calculée, c’est*
* une référence à un nom de variable (car, en JavaScript, les* Cette interface hérite de celle des opérations qui permet l’accès
* fonctions sont dans le même espace de nom).* à l’opérateur et à la liste des opérandes.
10 */*/
8
public interface IASTinvocation extends IAST {public interface IASTbinaryOperation extends IASToperation {
/** Renvoie la fonction invoquée. *//** renvoie l’opérande de gauche. */
15 IAST getFunction ();IAST getLeftOperand ();
13
/** Renvoie les arguments de l’invocation sous forme d’une liste. *//** renvoie l’opérande de droite. */
IAST[] getArguments ();IAST getRightOperand ();
}
20 /** Renvoie le nombre d’arguments de l’invocation. */
int getArgumentsLength ();
Java/src/fr/upmc/ilp/ilp1/interfaces/IASTboolean.java /** Renvoie le i-ème argument de l’invocation ou null. */
@OrNull IAST getArgument (int i);
25 }
package fr.upmc.ilp.ilp1.interfaces;
3 /** Decrit la citation d’un booleen. */ Java/src/fr/upmc/ilp/ilp1/interfaces/IASToperation.java
public interface IASTboolean extends IASTconstant {
/** Renvoie le booleen cite. */ package fr.upmc.ilp.ilp1.interfaces;
boolean getValue ();
8 }
4 /** Interface décrivant les opérations.
*
* Une opération implique un opérateur et un ou plusieurs opérandes.Java/src/fr/upmc/ilp/ilp1/interfaces/IASTconstant.java
* Les opérations peuvent être unaires ou binaires cf. les
* sous-interfaces appropriées.
9 */package fr.upmc.ilp.ilp1.interfaces;
2
public interface IASToperation extends IAST {/** Decrit une constante litterale. Cette interface n’existe que pour
* etre raffinee en des sous-interfaces plus specialisees. */
/** Renvoie le nom de l’opérateur concerné par l’opération. */
14 String getOperatorName ();public interface IASTconstant extends IAST {}
/** Renvoie l’arité de l’opérateur concerné par l’opération. L’arité
* est toujours de 1 pour une IASTunaryOperation et de 2 pour une
Java/src/fr/upmc/ilp/ilp1/interfaces/IAST oat.java * IASTbinaryOperation. */
19 int getArity ();
/** Renvoie les opérandes d’une opération.package fr.upmc.ilp.ilp1.interfaces;
*
import java.math.BigDecimal; * NOTA: cette méthode est générale, les méthodes d’accès aux
4 24 * opérandes des opérations unaires ou binaires sont, probablement,
* plus efficaces./** Citation d’un flottant. */
*
* NOTA2: normalement le nombre d’operandes doit être égal à l’aritépublic interface IASTfloat extends IASTconstant {
* de l’opérateur (mais il se peut que certains opérateurs soit n-aires)/** Renvoie le flottant cité comme constante. */
29 * auquel cas, que l’arité soit un simple entier n’est pas une bonne idée!9 BigDecimal getValue ();
*/}
IAST[] getOperands ();
}
Java/src/fr/upmc/ilp/ilp1/interfaces/IASTinteger.java
Java/src/fr/upmc/ilp/ilp1/interfaces/IASTsequence.java
package fr.upmc.ilp.ilp1.interfaces;
package fr.upmc.ilp.ilp1.interfaces;
import java.math.BigInteger;
2
import fr.upmc.ilp.annotation.OrNull;
5 /** Citation d’un entier. */
/** Décrit une séquence d’instructions. On reprend le mêmepublic interface IASTinteger extends IASTconstant {
* style d’interface que IASTinvocation. */
/** Renvoie l’entier cite comme constante. */
7
BigInteger getValue ();
public interface IASTsequence extends IAST {
10 }
/** Renvoie la séquence des instructions contenues. */
IAST[] getInstructions ();
Java/src/fr/upmc/ilp/ilp1/interfaces/IASTinvocation.java
12
/** Renvoie le nombre d’instructions de la sequence. */
int getInstructionsLength ();
9 10package fr.upmc.ilp.ilp1.fromxml;
/** Renvoie la i-ème instruction ou null. */ 2 import fr.upmc.ilp.ilp1.interfaces.*;
17 @OrNull IAST getInstruction (int i);
public abstract class AST implements IAST {
// FUTURE ? ajouter getAllButLastInstructions() ???
} /** Décrit l’AST en XML (surtout utile pour la mise au point).
7 *
* NOTA: cette signature conduit à une implantation naïve
* déraisonnablement coûteuse! Il vaudrait mieux se trimballer unJava/src/fr/upmc/ilp/ilp1/interfaces/IASTstring.java
* unique StringBuffer dans lequel concaténer les fragments XML.
*/
12
package fr.upmc.ilp.ilp1.interfaces;
public abstract String toXML ();
/** Citation d’une chaine de caracteres.*/
}
4
public interface IASTstring extends IASTconstant {
/** Renvoie la chaine de caracteres citee. */
Java/src/fr/upmc/ilp/ilp1/fromxml/ASTException.javaString getValue ();
}
package fr.upmc.ilp.ilp1.fromxml;
Java/src/fr/upmc/ilp/ilp1/interfaces/IASTunaryBlock.java
/** Une exception comme les autres mais qu’utilisent préférentiellement
4 * les classes du paquetage fromxml.
*/
package fr.upmc.ilp.ilp1.interfaces;
2
public class ASTException extends Exception {/** Décrit un bloc local ne liant qu’une unique variable. */
9 static final long serialVersionUID = +1234567890001000L;
public interface IASTunaryBlock extends IAST {
public ASTException (Throwable cause) {7 /** Renvoie la variable liée localement. */
super(cause);IASTvariable getVariable();
}
14/** Renvoie l’expression initialisant la variable locale. */
IAST getInitialization(); public ASTException (String message) {
super(message);12
}/** Renvoie la sequence d’instructions présentes dans le corps du
* bloc local. */
19 }IASTsequence getBody();
}
Java/src/fr/upmc/ilp/ilp1/fromxml/ASTParser.java
Java/src/fr/upmc/ilp/ilp1/interfaces/IASTunaryOperation.java
package fr.upmc.ilp.ilp1.fromxml;
import java.util.List;package fr.upmc.ilp.ilp1.interfaces;
import java.util.Vector;
3 /** Interface décrivant les opérations unaires. */
5 import org.w3c.dom.Document;
import org.w3c.dom.Element;public interface IASTunaryOperation extends IASToperation {
import org.w3c.dom.Node;/** renvoie l’unique operande. */
import org.w3c.dom.NodeList;IAST getOperand ();
8 }
10 /** Le but de cette classe est de transformer un document XML en un
* AST conforme à fr.upmc.ilp.interfaces.IAST. */
Java/src/fr/upmc/ilp/ilp1/interfaces/IASTvariable.java public class ASTParser {
15 /** Constructeur. */
package fr.upmc.ilp.ilp1.interfaces;
2 public ASTParser () {}
/**
* Cette interface décrit une variable mais seulement une variable. D’autres /** Transformer un document (ou un n?ud) DOM en un AST (et donc un
* interfaces existent pour lire ou écrire des variables. Usuellement, les
20 * IAST).
* variables n’apparaissent que dans des lieurs (fonctions, methodes ou blocs *
7 * locaux). * C’est une grande méthode monolithique qui analyse le DOM (une
*/ * structure de données arborescente correspondant au document XML
* initial) en un AST où chaque n?ud est typé suivant sa catégorie
public interface IASTvariable extends IAST {
25 * syntaxique. Il est difficile d’avoir un style objet sur ce type
/** Renvoie le nom de la variable. */ * de code qui correspond à une construction. Nous verrons une
12 String getName(); * nouvelle organisation de ce code bientôt.
} *
* @throws ASTException en cas de problème.
30 * NOTA: comme le document d’entrée est supposé être valide pour le
* schéma RelaxNG approprié, de nombreux risques d’erreur sont ainsiJava/src/fr/upmc/ilp/ilp1/fromxml/AST.java
* éliminés et ne sont donc pas explicitement testés. Par exemple,
* le fait qu’un fils « condition » apparaît toujours sous «
* alternative, » que l’attribut « valeur » est présent dans «
35 * entier, » etc. Tous ces faits sont assumés corrects.
*/
11 12} else if ( "condition".equals(name) ) {
public AST parse (Node n) return this.parseUniqueChild(nl);
throws ASTException { } else if ( "consequence".equals(name) ) {
40 switch ( n.getNodeType() ) { return this.parseUniqueChild(nl);
120 } else if ( "alternant".equals(name) ) {
case Node.DOCUMENT_NODE: { return this.parseUniqueChild(nl);
Document d = (Document) n; } else if ( "valeur".equals(name) ) {
return this.parse(d.getDocumentElement()); return this.parseUniqueChild(nl);
45 }
125 // Une série d’éléments devant être analysée comme une séquence:
case Node.ELEMENT_NODE: {
} else if ( "corps".equals(name) ) {
Element e = (Element) n;
return new ASTsequence(this.parseList(nl));NodeList nl = e.getChildNodes();
50 String name = e.getTagName();
} else {
130 String msg = "Unknown element name: " + name;
if ( "programme1".equals(name) ) {
throw new ASTException(msg);return new ASTsequence(parseList(nl));
}
}
55 } else if ( "alternative".equals(name) ) {
AST cond = findThenParseChild(nl, "condition");
135 default: {
AST conseq = findThenParseChildAsInstructions(nl, "consequence");
String msg = "Unknown node type: " + n.getNodeName();
try {
throw new ASTException(msg);AST alt = findThenParseChildAsInstructions(nl, "alternant");
}60 return new ASTalternative(cond, conseq, alt);
}
} catch (ASTException exc) {
140 }return new ASTalternative(cond, conseq);
}
/** Analyser une séquence d’éléments pour en faire un ASTlist
* c’est-à-dire une séquence d’AST.
65 } else if ( "sequence".equals(name) ) { */
return new ASTsequence(this.parseList(nl));
145
protected List<AST> parseList (NodeList nl)
} else if ( "blocUnaire".equals(name) ) { throws ASTException {
ASTvariable var = (ASTvariable) findThenParseChild(nl, "variable"); List<AST> result = new Vector<AST>();
70 AST init = findThenParseChild(nl, "valeur"); int n = nl.getLength();
ASTsequence body = (ASTsequence) findThenParseChild(nl, "corps");
150 LOOP:
return new ASTblocUnaire(var, init, body);
for ( int i = 0 ; i<n ; i++ ) {
Node nd = nl.item(i);
} else if ( "variable".equals(name) ) {
switch ( nd.getNodeType() ) {
75 // La variable sera, suivant les contextes, encapsulée
// dans une référence.
155 case Node.ELEMENT_NODE: {
String nick = e.getAttribute("nom");
AST p = this.parse(nd);return new ASTvariable(nick);
result.add(p);
continue LOOP;
80 } else if ( "invocationPrimitive".equals(name) ) {
}
String op = e.getAttribute("fonction");
160
List<AST> largs = parseList(nl);
default: {
return new ASTinvocationPrimitive(op, largs.toArray(new AST[0]));
// On ignore tout ce qui n’est pas élément XML:
}
85 } else if ( "operationUnaire".equals(name) ) {
}
String op = e.getAttribute("operateur");
165 }
AST rand = findThenParseChild(nl, "operande");
return result;
return new ASToperationUnaire(op, rand);
}
90 } else if ( "operationBinaire".equals(name) ) { /** Trouver un élément d’après son nom et l’analyser pour en faire
String op = e.getAttribute("operateur");
170 * un AST.
AST gauche = findThenParseChild(nl, "operandeGauche"); *
AST droite = findThenParseChild(nl, "operandeDroit"); * @throws ASTException
return new ASToperationBinaire(op, gauche, droite); * lorsqu’un tel élément n’est pas trouvé.
95
*/
} else if ( "entier".equals(name) ) { 175
return new ASTentier(e.getAttribute("valeur")); protected AST findThenParseChild (NodeList nl, String childName)
throws ASTException {
} else if ( "flottant".equals(name) ) { int n = nl.getLength();
100 return new ASTflottant(e.getAttribute("valeur")); for ( int i = 0 ; i<n ; i++ ) {
180 Node nd = nl.item(i);
} else if ( "chaine".equals(name) ) { switch ( nd.getNodeType() ) {
String text = e.getTextContent();
return new ASTchaine(text); case Node.ELEMENT_NODE: {
105 Element e = (Element) nd;
} else if ( "booleen".equals(name) ) {
185 if ( childName.equals(e.getTagName()) ) {
return new ASTbooleen(e.getAttribute("valeur"));
return this.parse(e);
}
// Une série d’éléments devant être analysés comme des expressions:
break;
110 } else if ( "operandeGauche".equals(name) ) {
}
return this.parseUniqueChild(nl);
190
} else if ( "operandeDroit".equals(name) ) { default: {
return this.parseUniqueChild(nl); // On ignore tout ce qui n’est pas élément XML:
} else if ( "operande".equals(name) ) { }
115 return this.parseUniqueChild(nl); }
13 14195 } 1 package fr.upmc.ilp.ilp1.fromxml;
String msg = "No such child element " + childName;
import org.custommonkey.xmlunit.XMLTestCase;throw new ASTException(msg);
}
import fr.upmc.ilp.ilp1.interfaces.IAST;
200 /** Trouver un élément d’après son nom et analyser son contenu pour 6 import fr.upmc.ilp.ilp1.interfaces.IASTbinaryOperation;
import fr.upmc.ilp.ilp1.interfaces.IASTboolean;* en faire un ASTsequence.
import fr.upmc.ilp.ilp1.interfaces.IASTfloat;*
import fr.upmc.ilp.ilp1.interfaces.IASTinteger;* @throws ASTException
import fr.upmc.ilp.ilp1.interfaces.IASTinvocation;* lorsqu’un tel élément n’est pas trouvé.
205 */ 11 import fr.upmc.ilp.ilp1.interfaces.IASTsequence;
import fr.upmc.ilp.ilp1.interfaces.IASTstring;
import fr.upmc.ilp.ilp1.interfaces.IASTunaryBlock;protected ASTsequence findThenParseChildAsInstructions (
import fr.upmc.ilp.ilp1.interfaces.IASTunaryOperation;NodeList nl, String childName)
throws ASTException {
16 /** Tests (JUnit) simples d’equivalence depuis XML -> AST -> XML. */210 int n = nl.getLength();
for ( int i = 0 ; i<n ; i++ ) {
public class ASTParserTest extends XMLTestCase {Node nd = nl.item(i);
switch ( nd.getNodeType() ) {
public void testEntier () throws ASTException {
21 String program = "<entier valeur=’34’/>";215 case Node.ELEMENT_NODE: {
AST a = ASTfromXML.toAST(program);Element e = (Element) nd;
assertEquals(program, a.toXML());if ( childName.equals(e.getTagName()) ) {
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTentier);return new ASTsequence(this.parseList(e.getChildNodes()));
IASTinteger iast = (IASTinteger) a;}
26 assertEquals(34, iast.getValue().intValue());
220 break;
}
}
public void testEntierNeg () throws ASTException {
default: { String program = "<entier valeur=’-34’/>";
// On ignore tout ce qui n’est pas élément XML:
31 AST a = ASTfromXML.toAST(program);
225 }
assertEquals(program, a.toXML());
}
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTentier);}
IASTinteger iast = (IASTinteger) a;String msg = "No such child element " + childName;
assertEquals(-34, iast.getValue().intValue());
throw new ASTException(msg);
36 }
230 }
public void testFlottant () throws ASTException {/** Analyser une suite comportant un unique élément.
String program = "<flottant valeur=’3.14’/>";*
AST a = ASTfromXML.toAST(program);* @throws ASTException
41 assertEquals(program, a.toXML());
235 * lorsque la suite ne contient pas exactement un seul élément.
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTflottant);*/
IASTfloat iast = (IASTfloat) a;
assertEquals(3.14, iast.getValue().doubleValue(), 0.01);protected AST parseUniqueChild (NodeList nl)
}
throws ASTException {
46
240 AST result = null;
public void testFlottantExp () throws ASTException {int n = nl.getLength();
String program = "<flottant valeur=’-3.14e+3’/>";for ( int i = 0 ; i<n ; i++ ) {
AST a = ASTfromXML.toAST(program);Node nd = nl.item(i);
//assertEquals(program, a.toXML()); // Pas la meme forme en sortie!
switch ( nd.getNodeType() ) {
51 assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTflottant);
245
IASTfloat iast = (IASTfloat) a;
case Node.ELEMENT_NODE: {
assertEquals(-3140, iast.getValue().doubleValue(), 0.01);Element e = (Element) nd;
}
if ( result == null ) {
result = this.parse(e);
56 public void testBoolTrue () throws ASTException {
250 } else {
String program = "<booleen valeur=’true’/>";
String msg = "Non unique child";
AST a = ASTfromXML.toAST(program);
throw new ASTException(msg);
assertEquals(program, a.toXML());
}
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTbooleen);
break;
61 IASTboolean iast = (IASTboolean) a;
255 }
assertEquals(true, iast.getValue());
}
default: {
// On ignore tout ce qui n’est pas élément XML: public void testBoolFalse () throws ASTException {
}
66 String program = "<booleen valeur=’false’/>";
260 } AST a = ASTfromXML.toAST(program);
} assertEquals(program, a.toXML());
if ( result == null ) {
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTbooleen);
throw new ASTException("No child at all"); IASTboolean iast = (IASTboolean) a;
}
71 assertEquals(false, iast.getValue());
265 return result; }
}
public void testChaine () throws ASTException {
}
String program = "<chaine>foobar</chaine>";
76 AST a = ASTfromXML.toAST(program);
assertEquals(program, a.toXML());
Java/src/fr/upmc/ilp/ilp1/fromxml/ASTParserTest.java assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTchaine);
IASTstring iast = (IASTstring) a;
assertEquals("foobar", iast.getValue());
15 1681 } assertTrue(c instanceof fr.upmc.ilp.ilp1.fromxml.ASTsequence);
assertEquals(2, ((ASTsequence) c).getInstructions().length);
// {{{ String result = a.toXML();
// Bogue signalée par Jacques Malenfant <jacques.malenfant@lip6.fr>: assertXpathExists("/alternative", result);
// les conditions et consequences étaient incapables de prendre 166 assertXpathExists("/alternative/consequence", result);
86 // plusieurs instructions! On en profite pour utiliser XMLUnit assertXpathExists("/alternative/consequence/sequence", result);
// signalé par Jérémy Bobbio <jeremy.bobbio@etu.upmc.fr> assertXpathExists("/alternative/consequence/sequence/entier[@valeur=’1’]",
result);
assertXpathExists("/alternative/consequence/sequence/entier[@valeur=’11’]",public void testAlternativeTernaire () throws Exception {
171 result);String program = "<alternative>"
91 + "<condition><booleen valeur=’true’/></condition>" assertXpathExists("/alternative/alternant", result);
assertXpathExists("/alternative/alternant/sequence", result);+ "<consequence><entier valeur=’1’/></consequence>"
assertXpathEvaluatesTo("2",+ "<alternant><chaine>foobar</chaine></alternant>"
"count(/alternative/alternant/sequence/chaine)",+ "</alternative>";
176 result);AST a = ASTfromXML.toAST(program);
96 String result = a.toXML(); }
//System.err.println(result);
// }}}//assertEquals(program, result);
assertXpathExists("/alternative", result);
assertXpathExists("/alternative/condition", result); 181 public void testSequence () throws Exception {
101 assertXpathExists("/alternative/condition/booleen", result); String program = "<sequence>"
assertXpathExists("/alternative/consequence/sequence/entier", result); + "<booleen valeur=’true’/>"
assertXpathValuesEqual("1", + "<entier valeur=’1’/>"
"/alternative/consequence/sequence/entier/@valeur", + "</sequence>";
result); 186 AST a = ASTfromXML.toAST(program);
106 assertXpathExists("/alternative/alternant/sequence/chaine", result); assertEquals(program, a.toXML());
assertXpathValuesEqual("foobar", assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTsequence);
"/alternative/consequence/sequence/chaine", IASTsequence iast = (IASTsequence) a;
result); IAST[] iastlist = iast.getInstructions();
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTalternative); 191 assertNotNull(iastlist);
111 ASTalternative iast = (ASTalternative) a; assertTrue(iastlist.length == 2);
assertXMLEqual("<booleen valeur=’true’/>", IAST e1 = iastlist[0];
((AST)iast.getCondition()).toXML()); assertXMLEqual("<booleen valeur=’true’/>", ((AST)e1).toXML());
assertXMLEqual("<sequence><entier valeur=’1’/></sequence>", IAST e2 = iastlist[1];
((AST)iast.getConsequent()).toXML()); 196 assertXMLEqual("<entier valeur=’1’/>", ((AST)e2).toXML());
116 assertXMLEqual("<sequence><chaine>foobar</chaine></sequence>", }
((AST)iast.getAlternant()).toXML());
} public void testSequenceOne () throws Exception {
String program = "<sequence>"
public void testAlternativeBinaire () throws Exception { 201 + "<entier valeur=’1’/>"
121 String program = "<alternative>" + "</sequence>";
+ "<condition><booleen valeur=’true’/></condition>" AST a = ASTfromXML.toAST(program);
+ "<consequence><entier valeur=’1’/></consequence>" assertEquals(program, a.toXML());
+ "</alternative>"; assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTsequence);
AST a = ASTfromXML.toAST(program); 206 IASTsequence iast = (IASTsequence) a;
126 String result = a.toXML(); IAST[] iastlist = iast.getInstructions();
//assertEquals(program, a.toXML()); assertNotNull(iastlist);
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTalternative); assertTrue(iastlist.length == 1);
ASTalternative iast = (ASTalternative) a; IAST e1 = iastlist[0];
assertXMLEqual("<booleen valeur=’true’/>", 211 assertXMLEqual("<entier valeur=’1’/>", ((AST)e1).toXML());
131 ((AST)iast.getCondition()).toXML()); }
assertXMLEqual("<sequence><entier valeur=’1’/></sequence>",
((AST)iast.getConsequent()).toXML()); public void testSequenceEmpty () throws ASTException {
assertXpathExists("/alternative/consequence", result); String program = "<sequence>"
assertXpathExists("/alternative/consequence/sequence", result); 216 + "</sequence>";
136 assertXpathExists("/alternative/consequence/sequence/entier", result); AST a = ASTfromXML.toAST(program);
assertXpathNotExists("/alternative/alternant", result); assertEquals(program, a.toXML());
assertNull(iast.getAlternant()); assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTsequence);
} IASTsequence iast = (IASTsequence) a;
221 IAST[] iastlist = iast.getInstructions();
141 public void testAlternativeWithConsequences () throws ASTException { assertNotNull(iastlist);
String program = "<alternative>" assertTrue(iastlist.length == 0);
+ "<condition><booleen valeur=’true’/></condition>" }
+ "<consequence><entier valeur=’1’/><entier valeur=’11’/></consequence>"
+ "</alternative>"; 226 public void testVariable () throws ASTException {
146 AST a = ASTfromXML.toAST(program); String program = "<variable nom=’foo’/>";
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTalternative); AST a = ASTfromXML.toAST(program);
IAST c = ((ASTalternative) a).getConsequent(); assertEquals(program, a.toXML());
assertTrue(c instanceof fr.upmc.ilp.ilp1.fromxml.ASTsequence); assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTvariable);
assertEquals(2, ((ASTsequence) c).getInstructions().length);
231 assertTrue(a instanceof fr.upmc.ilp.ilp1.interfaces.IASTvariable);
151 } ASTvariable var = (ASTvariable) a;
assertEquals("foo", var.getName());
public void testAlternativeWithAlternants () throws Exception { }
String program = "<alternative>"
+ "<condition><booleen valeur=’true’/></condition>" 236 public void testBlocUnaire () throws Exception {
156 + "<consequence><entier valeur=’1’/><entier valeur=’11’/></consequence>" String program = "<blocUnaire>"
+ "<alternant><chaine>foo</chaine><chaine>bar</chaine></alternant>" + "<variable nom=’foo’/>"
+ "</alternative>"; + "<valeur><entier valeur=’11’/></valeur>"
AST a = ASTfromXML.toAST(program); + "<corps><variable nom=’bar’/></corps>"
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTalternative); 241 + "</blocUnaire>";
161 IAST c = ((ASTalternative) a).getConsequent(); AST a = ASTfromXML.toAST(program);
17 18//assertEquals(program, a.toXML()); IASTunaryOperation iast = (IASTunaryOperation) a;
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTblocUnaire); assertTrue(iast instanceof fr.upmc.ilp.ilp1.interfaces.IASTunaryOperation);
IASTunaryBlock iast = (ASTblocUnaire) a; //System.err.println(iast.getOperator().toXML());
246 assertTrue(iast instanceof fr.upmc.ilp.ilp1.interfaces.IASTunaryBlock); 326 assertEquals("-", iast.getOperatorName());
assertXMLEqual("<variable nom=’foo’/>", assertEquals(1, iast.getArity());
assertXMLEqual("<entier valeur=’123’/>",((AST)iast.getVariable()).toXML());
((AST)iast.getOperand()).toXML());assertXMLEqual("<entier valeur=’11’/>",
IAST[] iastlist = iast.getOperands();((AST)iast.getInitialization()).toXML());
251 //System.err.println(iast.getBody().toXML()); 331 assertTrue(iastlist.length == 1);
assertXMLEqual("<sequence><variable nom=’bar’/></sequence>", IAST e1 = iastlist[0];
assertXMLEqual("<entier valeur=’123’/>", ((AST)e1).toXML());((AST)iast.getBody()).toXML());
}}
336 public void testOperationBinaire () throws Exception {256 public void testInvocationPrimitive2 () throws Exception {
String program = "<operationBinaire operateur=’+’>"String program = "<invocationPrimitive fonction=’xy’>"
+ "<operandeGauche><entier valeur=’123’/></operandeGauche>"+ "<variable nom=’foo’/>"
+ "<entier valeur=’11’/>" + "<operandeDroit><entier valeur=’-34’/></operandeDroit>"
+ "</invocationPrimitive>"; + "</operationBinaire>";
341 AST a = ASTfromXML.toAST(program);261 AST a = ASTfromXML.toAST(program);
assertEquals(program, a.toXML());//assertEquals(program, a.toXML());
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTinvocationPrimitive); assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASToperationBinaire);
IASTbinaryOperation iast = (IASTbinaryOperation) a;IASTinvocation iast = (ASTinvocation) a;
assertTrue(iast instanceof fr.upmc.ilp.ilp1.interfaces.IASTbinaryOperation);assertTrue(iast instanceof fr.upmc.ilp.ilp1.interfaces.IASTinvocation);
266 assertEquals(2, iast.getArgumentsLength()); 346 //System.err.println(iast.getOperator().toXML());
assertEquals("<variable nom=’xy’/>", assertEquals("+", iast.getOperatorName());
assertEquals(2, iast.getArity());((AST)iast.getFunction()).toXML());
assertXMLEqual("<entier valeur=’123’/>",IAST[] iastlist = iast.getArguments();
((AST)iast.getLeftOperand()).toXML());assertTrue(iastlist.length == 2);
271 IAST e1 = iastlist[0]; 351 assertXMLEqual("<entier valeur=’-34’/>",
((AST)iast.getRightOperand()).toXML());assertXMLEqual("<variable nom=’foo’/>", ((AST)e1).toXML());
IAST[] iastlist = iast.getOperands();assertXMLEqual("<variable nom=’foo’/>",
assertTrue(iastlist.length == 2);((AST)iast.getArgument(0)).toXML());
AST e1 = (AST) iastlist[0];IAST e2 = iastlist[1];
276 assertXMLEqual("<entier valeur=’11’/>", ((AST)e2).toXML()); 356 assertXMLEqual("<entier valeur=’123’/>", e1.toXML());
AST e2 = (AST) iastlist[1];assertXMLEqual("<entier valeur=’11’/>",
assertXMLEqual("<entier valeur=’-34’/>", e2.toXML());((AST)iast.getArgument(1)).toXML());
}}
}
281 public void testInvocationPrimitive1 () throws Exception {
String program = "<invocationPrimitive fonction=’xy’>"
+ "<entier valeur=’11’/>" Java/src/fr/upmc/ilp/ilp1/fromxml/ASTalternative.java
+ "</invocationPrimitive>";
AST a = ASTfromXML.toAST(program);
286 //assertEquals(program, a.toXML()); package fr.upmc.ilp.ilp1.fromxml;
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTinvocationPrimitive); import fr.upmc.ilp.annotation.OrNull;
IASTinvocation iast = (ASTinvocation) a; import fr.upmc.ilp.ilp1.interfaces.IAST;
assertTrue(iast instanceof fr.upmc.ilp.ilp1.interfaces.IASTinvocation); 4 import fr.upmc.ilp.ilp1.interfaces.IASTalternative;
assertEquals(1, iast.getArgumentsLength());
291 assertEquals("<variable nom=’xy’/>", /** La représentation des alternatives (binaires ou ternaires). */
((AST)iast.getFunction()).toXML());
IAST[] iastlist = iast.getArguments(); public class ASTalternative extends AST
assertTrue(iastlist.length == 1); 9 implements IASTalternative {
IAST e1 = iastlist[0];
296 assertXMLEqual("<entier valeur=’11’/>", ((AST)e1).toXML());
public ASTalternative (AST condition,
assertXMLEqual("<entier valeur=’11’/>", AST consequence,
((AST)iast.getArgument(0)).toXML()); AST alternant ) {
}
14 this.condition = condition;
this.consequence = consequence;
301 public void testInvocationPrimitive0 () throws Exception {
this.alternant = alternant;String program = "<invocationPrimitive fonction=’xy’>"
}
+ "</invocationPrimitive>";
AST a = ASTfromXML.toAST(program);
19 // NOTA: Masquer l’implantation de l’alternative binaire afin//assertEquals(program, a.toXML());
// d’éviter la propagation de null.
306 assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASTinvocationPrimitive);
IASTinvocation iast = (ASTinvocation) a;
public ASTalternative (AST condition, AST consequence) {
assertTrue(iast instanceof fr.upmc.ilp.ilp1.interfaces.IASTinvocation);
this(condition, consequence, null);assertEquals(0, iast.getArgumentsLength());
24 }
assertXMLEqual("<variable nom=’xy’/>",
311 ((AST)iast.getFunction()).toXML());
private final AST condition;IAST[] iastlist = iast.getArguments();
private final AST consequence;assertTrue(iastlist.length == 0);
} private final AST alternant;
29
316 public void testOperationUnaire () throws Exception { public IAST getCondition () {
String program = "<operationUnaire operateur=’-’>" return this.condition;
+ "<operande><entier valeur=’123’/></operande>" }
+ "</operationUnaire>";
AST a = ASTfromXML.toAST(program);
34 public IAST getConsequent () {
321 assertEquals(program, a.toXML()); return this.consequence;
assertTrue(a instanceof fr.upmc.ilp.ilp1.fromxml.ASToperationUnaire); }
19 20