diff --git a/sablecc/sablecc.jar b/sablecc/sablecc.jar new file mode 100644 index 0000000000000000000000000000000000000000..a6187d566eb5524116975e8e2ff324eafe1762c6 Binary files /dev/null and b/sablecc/sablecc.jar differ diff --git a/sablecc/sablecc_thesis.pdf b/sablecc/sablecc_thesis.pdf new file mode 100644 index 0000000000000000000000000000000000000000..c76b634d006c34214caf5df1587f598d652480ed Binary files /dev/null and b/sablecc/sablecc_thesis.pdf differ diff --git a/src/.gitignore b/src/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..871caa1526ad40a35eb85fb1032681e585fa4fba --- /dev/null +++ b/src/.gitignore @@ -0,0 +1,4 @@ +*\.class +*/*\.class +*/*/*\.class +*~ \ No newline at end of file diff --git a/src/C3aVM.java b/src/C3aVM.java new file mode 100644 index 0000000000000000000000000000000000000000..a8bb3410c1eda526ffc8aae1f831508bfb67fcca --- /dev/null +++ b/src/C3aVM.java @@ -0,0 +1,67 @@ +import java.io.IOException; +import c3a.C3a; +import c3a.C3aEval; +import c3a.LoadC3a; +import ts.Ts; +import ts.TsParser; + +public class C3aVM { + private int verboseLevel = 0; + private TsParser stParser; + private String symbolsTableFileName; + private String C3AFileName; + private int stackSize; + private C3a code; + private Ts globalTable; + private LoadC3a loadC3a; + + public C3aVM(String symbolsTableFileName, String C3AFileName, int stackSize, int verboseLevel){ + this.stackSize = stackSize; + this.verboseLevel = verboseLevel; + this.symbolsTableFileName = symbolsTableFileName; + this.C3AFileName = C3AFileName; + stParser = new TsParser(); + this.globalTable = stParser.parse(symbolsTableFileName); + loadC3a = new LoadC3a(C3AFileName, this.globalTable); + this.code = loadC3a.getC3a(); + } + + + public void run() throws IOException { + if(verboseLevel > 0) + code.affiche(null); + C3aEval c3aEval = new C3aEval(code, globalTable, stackSize, verboseLevel); + code.accept(c3aEval); + c3aEval.affiche(null); + // eval.affiche(C3AFileName.substring(0, C3AFileName.length() - 4)); + + } + + public static void main(String[] args){ + int verboseLevel = 0; + String symbolsTableFileName = null; + String C3AFileName = null; + int stackSize = 10000; + + try { + for (int i = 0; i < args.length; i++) { + if(args[i].equals("-v")) + verboseLevel = Integer.parseInt(args[++i]); + else if(args[i].equals("-s")) + stackSize = Integer.parseInt(args[++i]); + else if(args[i].equals("-c3a")) + C3AFileName = args[++i]; + else if(args[i].equals("-ts")) + symbolsTableFileName = args[++i]; + } + if(C3AFileName == null || symbolsTableFileName == null){ + System.out.println("java C3aVM -c3a C3AFile -ts TSFile -s stackSize -v verboseLevel"); + System.exit(1); + } + C3aVM vm = new C3aVM(symbolsTableFileName, C3AFileName, stackSize, verboseLevel); + vm.run(); + }catch(IOException e){ + e.printStackTrace(); + } + } +} diff --git a/src/Compiler.java b/src/Compiler.java new file mode 100644 index 0000000000000000000000000000000000000000..39aebb826badfb5cf6e1f659e38d62a28e717f9a --- /dev/null +++ b/src/Compiler.java @@ -0,0 +1,215 @@ +import lParser.parser.*; +import lParser.lexer.*; +import lParser.node.*; +import java.io.*; +import sc.*; +import sa.*; +import ts.*; +import c3a.*; +import nasm.*; +import fg.*; +import ig.*; +import util.Error; + + +public class Compiler +{ + private static String baseName = null; + private static String inputFileName = null; + private static int verboseLevel = 0; + private static Start scRoot = null; + private static SaProg saRoot = null; + private static Ts tableGlobale = null; + private static C3a c3a = null; + private static Nasm nasm = null; + private static Fg flowGraph = null; + private static FgSolution flowGraphSolution = null; + private static Ig interferenceGraph = null; + + + public static void main(String[] args) { + processCommandLine(args); + System.out.println("[BUILD SC] "); + buildSc(); + /* System.out.println("[BUILD SA] "); + buildSa(); + System.out.println("[BUILD TS] "); + buildTs(); + System.out.println("[TYPE CHECKING]"); + typeCheck(); + System.out.println("[BUILD C3A] "); + buildC3a(); + System.out.println("[BUILD PRE NASM] "); + buildPreNasm(); + System.out.println("[BUILD FLOW GRAPH] "); + buildFg(); + System.out.println("[SOLVE FLOW GRAPH]"); + solveFg(); + System.out.println("[BUILD INTERFERENCE GRAPH] "); + buildIg(); + System.out.println("[ALLOCATE REGISTERS]"); + interferenceGraph.allocateRegisters(); + System.out.println("[PRINT NASM]"); + nasm.afficheNasm(baseName); + System.exit(Error.NOERROR.code());*/ + } + + private static void processCommandLine(String[] args) { + for (int i = 0; i < args.length; i++) { + if (args[i].equals("-v")) { + verboseLevel = Integer.parseInt(args[++i]); + } else { + inputFileName = args[i]; + baseName = removeSuffix(inputFileName, ".l"); + } + } + if (inputFileName == null) { + System.out.println("java Compiler input_file -v verbose_level"); + System.exit(1); + } + } + + private static void buildSc() { + PushbackReader fileReader = null; + Parser parser = null; + try { + fileReader = new PushbackReader(new FileReader(inputFileName)); + } catch (IOException e) { + System.err.println("cannot open input file"); + e.printStackTrace(); + } + try { + parser = new Parser(new Lexer(fileReader)); + scRoot = parser.parse(); + } catch (ParserException e) { + System.err.println("syntax error"); + e.printStackTrace(); + System.exit(Error.SYNT.code()); + } catch (LexerException e) { + System.err.println("lexical error"); + e.printStackTrace(); + System.exit(Error.LEX.code()); + } catch (IOException e) { + e.printStackTrace(); + } + if (verboseLevel > 1) { + System.out.println("[PRINT SC]"); + scRoot.apply(new Sc2Xml(baseName)); + } + } + + private static void buildSa() { + try { + Sc2sa sc2sa = new Sc2sa(); + scRoot.apply(sc2sa); + saRoot = sc2sa.getRoot(); + } catch (Exception ignored) { + } + PrintStream out = System.out; + if (verboseLevel > 1) { + System.out.println("[PRINT SA]"); + try { + out = new PrintStream(baseName + ".sa"); + } + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + out.println(saRoot); + //new Sa2Xml(saRoot, baseName); + } + } + + private static void buildTs() { + try { + Sa2ts sa2ts = new Sa2ts(); + saRoot.accept(sa2ts); + tableGlobale = sa2ts.getTableGlobale(); + SaCheckLinkage saCheckLinkage = new SaCheckLinkage(); + saCheckLinkage.visit(saRoot); + if (tableGlobale.getFct("main") == null) + throw new ErrorException(Error.TS, "la fonction main n'est pas définie"); + } catch (ErrorException e) { + System.err.print("ERREUR TABLE DES SYMBOLES : "); + System.err.println(e.getMessage()); + System.exit(e.getCode()); + } catch (Exception ignored) { + } + if (verboseLevel > 1) { + System.out.println("[PRINT TS]"); + tableGlobale.afficheTout(baseName); + } + } + + private static void typeCheck() { + new SaTypeCheck(saRoot); + } + + private static void buildC3a() { + try{ + Sa2c3a sa2c3a = new Sa2c3a(saRoot, tableGlobale); + saRoot.accept(sa2c3a); + c3a = sa2c3a.getC3a(); + } + catch(Exception e){} + + if (verboseLevel > 1) { + System.out.println("[PRINT C3A] "); + c3a.affiche(baseName); + } + } + + private static void buildPreNasm() { + C3a2nasm c3a2nasm = new C3a2nasm(c3a, tableGlobale); + c3a.accept(c3a2nasm); + nasm = c3a2nasm.getNasm(); + if (verboseLevel > 1) { + System.out.println("[PRINT PRE NASM] "); + nasm.affichePreNasm(baseName); + } + } + + + private static void buildFg() { + flowGraph = new Fg(nasm); + if (verboseLevel > 1) { + System.out.println("[PRINT FLOW GRAPH] "); + flowGraph.affiche(baseName); + } + } + + private static void solveFg() { + flowGraphSolution = new FgSolution(nasm, flowGraph); + if (verboseLevel > 1) { + System.out.println("[PRINT FLOW GRAPH SOLUTION] "); + flowGraphSolution.affiche(baseName); + } + } + + private static void buildIg() { + interferenceGraph = new Ig(flowGraphSolution); + if (verboseLevel > 1) { + System.out.println("[PRINT INTERFERENCE GRAPH] "); + interferenceGraph.affiche(baseName); + } + } + + + + /*catch (Exception e) + { + e.printStackTrace(); + System.out.println(e.getMessage()); + System.exit(1); + } + }*/ + + + public static String removeSuffix(final String s, final String suffix) + { + if (s != null && suffix != null && s.endsWith(suffix)){ + return s.substring(0, s.length() - suffix.length()); + } + return s; + } + +} diff --git a/src/Makefile b/src/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..b64a54cfb52d4ed71cb744d8ded611b48cd6b86c --- /dev/null +++ b/src/Makefile @@ -0,0 +1,52 @@ +all: Compiler C3aVM NasmVM SaVM + +SaVM: SaVM.java saParser + javac SaVM.java + +NasmVM.jar : NasmVM + jar cmf NasmVM.mf NasmVM.jar NasmVM.class nasm + +C3aVM: C3aVM.java c3aParser + javac C3aVM.java + +NasmVM: NasmVM.java nasmParser + javac NasmVM.java + +Compiler.jar : Compiler + jar cmf Compiler.mf Compiler.jar *.class sc sa ts nasm util c3a fg ig lParser + +Compiler: Compiler.java lParser + javac Compiler.java + +lParser: l.cfg + java -jar ../sablecc/sablecc.jar l.cfg + +saParser: sa.cfg + java -jar ../sablecc/sablecc.jar sa.cfg + +c3aParser: c3a.cfg + java -jar ../sablecc/sablecc.jar c3a.cfg + +nasmParser: nasm.cfg + java -jar ../sablecc/sablecc.jar nasm.cfg + +ualParser: ual.cfg + java -jar ../sablecc/sablecc.jar ual.cfg + +clean: + -rm *.class + -rm sc/*.class + -rm sa/*.class + -rm c3a/*.class + -rm ts/*.class + -rm nasm/*.class + -rm fg/*.class + -rm ig/*.class + -rm util/intset/*.class + -rm util/graph/*.class + -rm util/*.class + -rm -r lParser + -rm -r saParser + -rm -r c3aParser + -rm -r nasmParser + diff --git a/src/NasmVM.java b/src/NasmVM.java new file mode 100644 index 0000000000000000000000000000000000000000..28c41c611bdced47859ae5ccb6aee7a1630ff342 --- /dev/null +++ b/src/NasmVM.java @@ -0,0 +1,66 @@ +import ts.Ts; +import ts.TsParser; +import nasm.NasmEval; +import nasm.Nasm; +import nasm.LoadNasm; +import java.io.IOException; + + +public class NasmVM { + private int verboseLevel; + private int stackSize; + private Nasm code; + private String nasmFileName; + + public NasmVM(String nasmFileName, int stackSize, int verboseLevel){ + this.nasmFileName = nasmFileName; + this.stackSize = stackSize; + this.verboseLevel = verboseLevel; + } + + public void run() throws IOException { + LoadNasm loadNasm = new LoadNasm(nasmFileName); + this.code = loadNasm.getNasm(); + + if(verboseLevel > 0) + code.afficheNasm(null); + + NasmEval eval = new NasmEval(code, stackSize, verboseLevel); + eval.displayOutput(); + } + + public static void main(String[] args){ + int verboseLevel = 0; + int stackSize = 10000; + String nasmFileName = null; + + try { + for (int i = 0; i < args.length; i++) { + if(args[i].equals("-v")) + verboseLevel = Integer.parseInt(args[++i]); + else if(args[i].equals("-s")) + stackSize = Integer.parseInt(args[++i]); + else if(args[i].equals("-nasm")) + nasmFileName = args[++i]; + } + if(nasmFileName == null){ + System.out.println("java NasmVM -nasm nasmFile -s stackSize -v verboseLevel"); + System.exit(1); + } + var vm = new NasmVM(nasmFileName, stackSize, verboseLevel); + vm.run(); + }catch(IOException e){ + e.printStackTrace(); + } + } +} + +/* + else{ + var pathTab = preNasmFilePath.split("/"); + var fileNamePreNasm = pathTab[pathTab.length - 1]; + var fileName = outputPath + fileNamePreNasm.substring(0, fileNamePreNasm.length()-3)+ ".out"; + vm.displayOutput(fileName); + } + } +*/ diff --git a/src/SaVM.java b/src/SaVM.java new file mode 100644 index 0000000000000000000000000000000000000000..0588a6e4ac553f63b493023ac81fa096643e8dde --- /dev/null +++ b/src/SaVM.java @@ -0,0 +1,46 @@ +import sa.*; +import ts.*; + +public class SaVM { + + public static void main(String[] args) { + int verboseLevel = 0; + String saFileName = null; + + try { + for (int i = 0; i < args.length; i++) { + if(args[i].equals("-v")) + verboseLevel = Integer.parseInt(args[++i]); + else if(args[i].equals("-sa")) + saFileName = args[++i]; + } + if(saFileName == null){ + System.out.println("java SaVM -sa saFile -v verboseLevel"); + System.exit(1); + } + + if(verboseLevel > 0) + System.err.println("parsing xml document"); + if(verboseLevel > 0) + System.err.println("building sa tree"); + + SaProg prog = new LoadSa(saFileName).getRoot(); + if(verboseLevel > 0) + System.out.println(prog); + + if(verboseLevel > 0) + System.err.println("building symbol table"); + Sa2ts sa2ts = new Sa2ts(); + prog.accept(sa2ts); + Ts tableGlobale = sa2ts.getTableGlobale(); + + if(verboseLevel > 0) + System.err.println("evaluating sa tree"); + SaEval saEval = new SaEval(prog, tableGlobale); + saEval.affiche(null); + + } catch (Exception e) { + e.printStackTrace(); + } + } +} diff --git a/src/c3a.cfg b/src/c3a.cfg new file mode 100644 index 0000000000000000000000000000000000000000..0737c8bfa0ab825607216415bdcd5941de62244f --- /dev/null +++ b/src/c3a.cfg @@ -0,0 +1,113 @@ +Package c3aParser; + +Helpers + +lettre = [['a' .. 'z'] + ['A' .. 'Z']]; +chiffre = ['0' .. '9']; +alpha = [lettre + ['_' + '$']]; +alphanum = [lettre + chiffre]; + +Tokens + +espaces = (' ' | 13 | 10 | 9)+; +commentaire= '#' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13); + + +co = '['; +cf = ']'; +call = 'call'; +stop = 'stop'; +fbegin = 'fbegin'; +fend = 'fend'; +aff = '='; +noteq = '!='; +inf = '<'; +infeq = '<='; +sup = '>'; +supeq = '>='; +eq = '=='; +goto = 'goto'; +param = 'param'; +ret = 'ret'; +if = 'if'; +moins = '-'; +plus = '+'; +fois = '*'; +divise = '/'; +write = 'write'; +read = 'read'; +nombre = chiffre+; +prefixe_temp = '@'; +identif = alpha alphanum*; + + +Ignored Tokens + +espaces, commentaire; + +Productions + +prog = listeinst; + +listeinst = {recursif} inst listeinst | + {final} inst + ; + +inst = {add} add | + {sub} sub | + {mul} mul | + {div} div | + {aff} affect | + {jmp} jmp | + {jmpeg} jmpeg | + {jmpneg} jmpneg | + {jmpinf} jmpinf | + {jminfeg} jmpinfeg | + {jmpsup} jmpsup | + {jmpsupeg} jmpsupeg | + {fcall} fcall | + {iwrite} iwrite | + {iread} iread | + {arg} arg | + {return} return | + {begin} begin | + {end} end | + {stop} istop + ; + +add = etiqop [result]:tv aff [op1]:ctv plus [op2]:ctv; +sub = etiqop [result]:tv aff [op1]:ctv moins [op2]:ctv; +mul = etiqop [result]:tv aff [op1]:ctv fois [op2]:ctv; +div = etiqop [result]:tv aff [op1]:ctv divise [op2]:ctv; +affect = etiqop [result]:tv aff [op1]:ctv; +jmpeg = etiqop if [op1]:ctv eq [op2]:ctv goto [result]:constante; +jmpneg = etiqop if [op1]:ctv noteq [op2]:ctv goto [result]:constante; +jmpinf = etiqop if [op1]:ctv inf [op2]:ctv goto [result]:constante; +jmpinfeg = etiqop if [op1]:ctv infeq [op2]:ctv goto [result]:constante; +jmpsup = etiqop if [op1]:ctv sup [op2]:ctv goto [result]:constante; +jmpsupeg = etiqop if [op1]:ctv supeq [op2]:ctv goto [result]:constante; +jmp = etiqop goto [result]:constante; +begin = identif fbegin; +end = etiqop fend; +fcall = etiqop [result]:tv aff call identif; +iwrite = etiqop write ctv; +iread = etiqop [result]:tv aff read; +arg = etiqop param ctv; +return = etiqop ret ctv; +istop = etiqop stop ctv; + + +ctv = {c} constante | {t} temporaire | {v} variable; +tv = {t} temporaire | {v} variable; + +constante = nombre; + +temporaire = prefixe_temp nombre; + +variable = {scalaire} identif | + {tab} identif co ctv cf + ; + +etiqop = {cte} nombre | + {vide} + ; diff --git a/src/c3a/C3a.java b/src/c3a/C3a.java new file mode 100644 index 0000000000000000000000000000000000000000..9fe8ad58c8b423dc159a6e45c540be0709907942 --- /dev/null +++ b/src/c3a/C3a.java @@ -0,0 +1,87 @@ +package c3a; +import java.util.*; +import java.io.*; +import ts.*; +import sa.*; + + +public class C3a{ + public List<C3aInst> listeInst; + // compteur des temporaires, pour générer des noms uniques + private int tempCounter; + // étiquette de la prochaine instruction, on retarde l'ajout de l'étiquette + private C3aLabel nextLabel; + private int labelCounter; + public C3aConstant True; + public C3aConstant False; + + public C3a(){ + this.listeInst = new ArrayList<C3aInst>(); + this.labelCounter = 0; + this.tempCounter = 0; + this.nextLabel = null; + this.True = new C3aConstant(1); // constantes utilisées partout + this.False = new C3aConstant(0); // constantes utilisées partout + } + + public int getTempCounter(){return this.tempCounter;} + public void setTempCounter(int value){this.tempCounter = value;} + public int getLabelCounter(){return this.labelCounter;} + public void setLableCounter(int value){this.labelCounter = value;} + + public void ajouteInst(C3aInst inst){ + if(this.nextLabel != null){ + inst.setLabel(this.nextLabel); + this.nextLabel = null; + } + this.listeInst.add(inst); + } + + public C3aLabel newAutoLabel(){ + return new C3aLabel(this.labelCounter++); + } + + public C3aTemp newTemp(){ + return new C3aTemp(this.tempCounter++); + } + + public void addLabelToNextInst(C3aLabel label){ + if(this.nextLabel != null){ + label.affect(this.nextLabel); + System.err.println("WARNING : Étiquette précédente ignorée " + this.nextLabel.getNumber()); + } + this.nextLabel = label; + // if(etiquette->oper_type == O_ETIQUETTE){ + // etiquette->u.oper_etiquette.ligne = c3a->next; + //} + //if(etiquette->oper_type == O_FCT){ + // etiquette->u.oper_fct->adresse = c3a->next; + //} + } + + public void affiche(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".c3a"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + Iterator<C3aInst> iter = this.listeInst.iterator(); + while(iter.hasNext()){ + out.println(iter.next()); + } + } + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aBooleanConstant.java b/src/c3a/C3aBooleanConstant.java new file mode 100644 index 0000000000000000000000000000000000000000..419e5e9594910662e0a16ff356dd60ba0d3951b2 --- /dev/null +++ b/src/c3a/C3aBooleanConstant.java @@ -0,0 +1,15 @@ +package c3a; + +public class C3aBooleanConstant extends C3aOperand{ + public boolean val; + + public C3aBooleanConstant(boolean val){ + this.val = val; + } + + public String toString(){return String.valueOf(this.val);} + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/c3a/C3aConstant.java b/src/c3a/C3aConstant.java new file mode 100644 index 0000000000000000000000000000000000000000..657cdd3703253a2f0740666304c06c76f170720b --- /dev/null +++ b/src/c3a/C3aConstant.java @@ -0,0 +1,15 @@ +package c3a; + +public class C3aConstant extends C3aOperand{ + public int val; + + public C3aConstant(int val){ + this.val = val; + } + + public String toString(){return Integer.toString(this.val);} + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/c3a/C3aEval.java b/src/c3a/C3aEval.java new file mode 100644 index 0000000000000000000000000000000000000000..e1f2fd28fd1a611ce78cdb94d17202a07710edc8 --- /dev/null +++ b/src/c3a/C3aEval.java @@ -0,0 +1,385 @@ +package c3a; +import java.util.*; +import java.io.*; +import ts.*; +import util.Memory; +import util.Type; + +public class C3aEval implements C3aVisitor <Integer> { + private C3a c3a; + private Ts tableGlobale; + private int nbReg; + private int[] reg; + private int[] stack; + private Memory varGlob; + private int eip; + private int ebp; + private int esp; + private int stackSize; + private Map< Integer, Integer> label2index; + private Map< String, Integer> function2index; + private boolean debug; + private boolean stop; + private ArrayList<String> programOutput = new ArrayList<String>(); + private TsItemFct currentFct; + private Stack<TsItemFct> stackCurrentFct; + + private C3aOperand storeReturnValue; + private Stack<C3aOperand> stackStoreReturnValue; + private int verboseLevel; + + + public C3aEval(C3a c3a, Ts tableGlobale, int stackSize, int verboseLevel){ + debug = true; + this.verboseLevel = verboseLevel; + this.c3a = c3a; + stack = new int[stackSize]; + nbReg = c3a.getTempCounter(); + reg = new int[nbReg]; + esp = 0; + varGlob = new Memory(tableGlobale.getAdrVarCourante(), 0); + this.tableGlobale = tableGlobale; + this.currentFct = null; + storeReturnValue = null; + label2index = new HashMap< Integer, Integer>(); + function2index = new HashMap< String, Integer>(); + C3aInst c3aInst = null; + stackCurrentFct = new Stack<>(); + stackStoreReturnValue = new Stack<>(); + eip = 0; + + for(int i = 0; i < c3a.listeInst.size(); i++){ + c3aInst = c3a.listeInst.get(i); + if(c3aInst.label != null){ + label2index.put(c3aInst.label.number, i); + } + if(c3aInst instanceof C3aInstFBegin){ + String identif = ((C3aInstFBegin)c3aInst).val.identif; + function2index.put(identif, i); + } + } + + } + + public C3a getC3a(){ + return this.c3a; + } + public void afficheEtat(C3aInst inst){ + System.out.println("---------------------------------------------"); + System.out.println("eip = " + eip + "\tesp = " + esp + "\tebp = " + ebp); + System.out.print("PILE : "); + affichePile(); + System.out.print("REGISTRES : "); + afficheReg(); + System.out.println(inst); + } + + + + public void affiche(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".c3aout"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + for (String line : programOutput) + out.println(line); + } + + + public void affichePileVertical(){ + for(int i = esp-1; i >= 0; i--){ + System.out.println(i + ":" + stack[i]); + } + } + + public void affichePile(){ + for(int i = 0; i < esp; i++){ + System.out.print(stack[i] + " "); + } + System.out.println(""); + + } + + public void push(int i){ + if(esp == stackSize){ + System.out.println("stack overflow !!!"); + System.exit(1); + } + stack[esp] = i; + esp++; + } + + public void afficheReg(){ + for(int i=0; i <nbReg; i++) + System.out.print(i + ":" + reg[i] + " "); + System.out.println(""); + } + + public void pushReg(){ + // System.out.println("pushReg " + nbReg + " registers"); + for(int i=0; i <nbReg; i++) + push(reg[i]); + } + + public void popReg(){ + // System.out.println("popReg " + nbReg + " registers"); + for(int i=nbReg-1; i >=0; i--) + reg[i] = pop(); + } + + public int pop(){ + if(esp == 0){ + System.out.println("cannot pop empty stack !!!"); + System.exit(1); + } + esp--; + return stack[esp]; + } + + public Integer visit(C3a c3a){ + stop = false; + C3aInst c3aInst; + while(!stop){ + c3aInst = c3a.listeInst.get(eip); + // System.out.println("<" + c3aInst.getClass().getSimpleName() + ">"); + if(verboseLevel > 0) + afficheEtat(c3aInst); + + c3aInst.accept(this); + } + return 0; + } + public Integer visit(C3aConstant constant){ + return constant.val; + } + + public Integer visit(C3aBooleanConstant constant){ + return (constant.val == true)? 1 : 0; + } + + public Integer visit(C3aTemp temp){ + return reg[temp.num]; + } + + public Integer visit(C3aVar var){ + int adresse = var.item.adresse; + Type type = var.item.type; + // variable globale + if(var.item.portee == this.tableGlobale){ + int offset = (var.index != null)? var.index.accept(this) : 0; + // return varGlob[adresse/4 + offset]; + // System.out.println("adresse = " + adresse + " taille = " + type.taille()); + return varGlob.readNBytes(adresse + offset * type.taille(), type.taille()); + } + if(var.item.isParam){ // parametre + int nbArgs = this.currentFct.nbArgs; + return stack[ebp - 2 - nbArgs + adresse / 4]; + } + // variable locale + return stack[ebp + 1 + adresse / 4]; + } + + public void affect(C3aOperand op, int val){ + if(op instanceof C3aVar){ + C3aVar var = (C3aVar) op; + int adresse = var.item.adresse; + int size = var.item.getType().taille(); + // variable globale + if(var.item.portee == this.tableGlobale){ + int offset = (var.index != null)? var.index.accept(this) : 0; + varGlob.writeInt(adresse + offset * size, val); + } + else if(var.item.isParam){ // parametre + int nbArgs = this.currentFct.nbArgs; + stack[ebp - 2 - nbArgs + adresse/4] = val; + } + else // variable locale + stack[ebp + 1 + adresse/4] = val; + } + else if(op instanceof C3aTemp){ + C3aTemp temp = (C3aTemp) op; + reg[temp.num] = val; + } + } + + public Integer visit(C3aFunction fct){ + return null; + } + + public Integer visit(C3aLabel label){ + return label.number; + } + /*--------------------------------------------------------------------------------------------------------------*/ + + public Integer visit(C3aInstStop inst){ + stop = true; + return null; + } + + public Integer visit(C3aInstAdd inst){ + //if(debug){afficheEtat(inst);} + affect(inst.result, inst.op1.accept(this) + inst.op2.accept(this)); + eip++; + return null; + } + + public Integer visit(C3aInstSub inst){ + //if(debug){afficheEtat(inst);} + affect(inst.result, inst.op1.accept(this) - inst.op2.accept(this)); + eip++; + return null; + } + + public Integer visit(C3aInstMult inst){ + //if(debug){afficheEtat(inst);} + affect(inst.result, inst.op1.accept(this) * inst.op2.accept(this)); + eip++; + return null; + } + + public Integer visit(C3aInstDiv inst){ + //if(debug){afficheEtat(inst);} + affect(inst.result, inst.op1.accept(this) / inst.op2.accept(this)); + eip++; + return null; + } + + public Integer visit(C3aInstJumpIfLess inst){ + //if(debug){afficheEtat(inst);} + if(inst.op1.accept(this) < inst.op2.accept(this)) + eip = label2index.get(inst.result.accept(this)); + else + eip++; + return null; + } + + public Integer visit(C3aInstJumpIfEqual inst){ + //if(debug){afficheEtat(inst);} + if(inst.op1.accept(this) == inst.op2.accept(this)) + eip = label2index.get(inst.result.accept(this)); + else + eip++; + return null; + } + + public Integer visit(C3aInstJumpIfNotEqual inst){ + //if(debug){afficheEtat(inst);} + if(inst.op1.accept(this) != inst.op2.accept(this)) + eip = label2index.get(inst.result.accept(this)); + else + eip++; + return null; + } + + public Integer visit(C3aInstJump inst){ + //if(debug){afficheEtat(inst);} + eip = label2index.get(inst.result.accept(this)); + return null; + } + + public Integer visit(C3aInstAffect inst){ + //if(debug){afficheEtat(inst);} + affect(inst.result, inst.op1.accept(this)); + eip++; + return null; + } + + public Integer visit(C3aInstParam inst){ + //if(debug){afficheEtat(inst);} + push(inst.op1.accept(this)); + eip++; + return null; + } + + public Integer visit(C3aInstReturn inst){ + //if(debug){afficheEtat(inst);} + stack[ebp - 2] = (inst.op1 != null)? inst.op1.accept(this) : 0; + eip++; + return null; + } + + public Integer visit(C3aInstWrite inst){ + //if(debug){afficheEtat(inst);} + programOutput.add(inst.op1.accept(this).toString()); + eip++; + return null; + } + + public Integer visit(C3aInstCall inst){ + //if(debug){afficheEtat(inst);} + // storeReturnValue = inst.result; + stackStoreReturnValue.push(inst.result); + // allocation mémoire pour la valeur de retour + //if(debug){System.out.println("allocation mémoire pour la valeur de retour, esp++");} + esp++; + //if(debug){System.out.println("sauvegarde de l'index de l'instruction à effectuer après l'appel : push(eip + 1)");} + push(eip + 1); + stackCurrentFct.push(currentFct); + eip = function2index.get(inst.op1.val.identif); + return null; + } + + public Integer visit(C3aInstFBegin inst){ + //if(debug){afficheEtat(inst);} + currentFct = inst.val; + int nbVarLoc = currentFct.getTable().getAdrVarCourante(); + + //if(debug){System.out.println("sauvegarde de l'ancienne valeur de ebp");} + push(ebp); + //if(debug){System.out.println("nouvelle valeur de ebp");} + ebp = esp - 1; + //if(debug){System.out.println("allocation des variables locales");} + esp = esp + nbVarLoc; + pushReg(); + eip++; + return null; + } + + public Integer visit(C3aInstFEnd inst){ + //if(debug){afficheEtat(inst);} + int nbVarLoc = currentFct.getTable().getAdrVarCourante(); + int nbParam = currentFct.nbArgs; + popReg(); + esp = esp - nbVarLoc; + ebp = pop(); + eip = pop(); + int rv = pop(); + storeReturnValue = stackStoreReturnValue.pop(); + if(storeReturnValue != null){ + affect(storeReturnValue, rv); + storeReturnValue = null; + } + currentFct = stackCurrentFct.pop(); + esp = esp - nbParam; + return null; + } + + public Integer visit(C3aInstRead inst){ + /* Int label = (inst.label != null) ? inst.label.accept(this) : null; + Int result = inst.result.accept(this); + NasmRegister reg_eax = nasm.newRegister(); + reg_eax.colorRegister(Nasm.REG_EAX); + + nasm.ajouteInst(new NasmMov (label, reg_eax, new NasmLabel("sinput"), "Read 1")); + nasm.ajouteInst(new NasmCall(null, new NasmLabel("readline"), "Read 2")); + nasm.ajouteInst(new NasmMov (null, reg_eax, new NasmLabel("sinput"), "Read 3")); + nasm.ajouteInst(new NasmMov (null, result, reg_eax , "Read 4"));*/ + eip++; + return null; + } + + + public Integer visit(C3aInst inst){ + return null;} + +} diff --git a/src/c3a/C3aFunction.java b/src/c3a/C3aFunction.java new file mode 100644 index 0000000000000000000000000000000000000000..5966b6a4da41c95e7180e9843274d2c2e2a4d7f7 --- /dev/null +++ b/src/c3a/C3aFunction.java @@ -0,0 +1,20 @@ +package c3a; +import ts.*; + + +public class C3aFunction extends C3aOperand{ + public TsItemFct val; + + public C3aFunction(TsItemFct val){ + this.val = val; + } + + public TsItemFct getValue(){return val;} + + public String toString(){ + return this.val.getIdentif(); + } + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/c3a/C3aInst.java b/src/c3a/C3aInst.java new file mode 100644 index 0000000000000000000000000000000000000000..9aafc68eb79a4d01da3670a2963dfcbcc0ea7410 --- /dev/null +++ b/src/c3a/C3aInst.java @@ -0,0 +1,16 @@ +package c3a; + +public class C3aInst{ + public C3aLabel label ; // étiquette optionnelle, si la ligne est cible d'un saut + public String comment; // commentaire explicatif - utile pour le débogage + + public void setLabel(C3aLabel label){ + this.label = label; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstAdd.java b/src/c3a/C3aInstAdd.java new file mode 100644 index 0000000000000000000000000000000000000000..49b9d92695eccf90a8915caaeef1da68ec25650f --- /dev/null +++ b/src/c3a/C3aInstAdd.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstAdd extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand op2; // opérande 2 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstAdd(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){ + this.op1 = op1; + this.op2 = op2; + this.result = result; + this.comment = comment; + } + + public String toString(){ + if(this.label != null) + return this.label + "\t" + this.result + " = " + this.op1 + " + " + this.op2 + this.comment; + else + return "\t" + this.result + " = " + this.op1 + " + " + this.op2 + this.comment; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstAffect.java b/src/c3a/C3aInstAffect.java new file mode 100644 index 0000000000000000000000000000000000000000..8596b7bc4d6f12e8a9169144adf3a16c6ae19d58 --- /dev/null +++ b/src/c3a/C3aInstAffect.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstAffect extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstAffect(C3aOperand op1, C3aOperand result, String comment){ + this.op1 = op1; + this.result = result; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) s = s + this.label; + s = s + "\t"; + s = s + this.result + " = " + this.op1 + this.comment; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + + +} + diff --git a/src/c3a/C3aInstCall.java b/src/c3a/C3aInstCall.java new file mode 100644 index 0000000000000000000000000000000000000000..dc5794fdba175ed546a679a280196cd5162c85aa --- /dev/null +++ b/src/c3a/C3aInstCall.java @@ -0,0 +1,28 @@ +package c3a; + +public class C3aInstCall extends C3aInst{ + public C3aFunction op1; // opérande 1 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstCall(C3aFunction op1, C3aOperand result, String comment){ + this.op1 = op1; + this.result = result; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + if(this.result != null) + s = s + this.result + " ="; + s = s + " call " + this.op1 + this.comment; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstDiv.java b/src/c3a/C3aInstDiv.java new file mode 100644 index 0000000000000000000000000000000000000000..77885d1feb97ec9dfd18b3464f87edaf5e765ca2 --- /dev/null +++ b/src/c3a/C3aInstDiv.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstDiv extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand op2; // opérande 2 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstDiv(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){ + this.op1 = op1; + this.op2 = op2; + this.result = result; + this.comment = comment; + } + + public String toString(){ + if(this.label != null) + return this.label + "\t" + this.result + " = " + this.op1 + " / " + this.op2 + this.comment; + else + return "\t" + this.result + " = " + this.op1 + " / " + this.op2 + this.comment; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstFBegin.java b/src/c3a/C3aInstFBegin.java new file mode 100644 index 0000000000000000000000000000000000000000..c8a5f2c5a99cf8d248b70d7700a3b3ada08a38c5 --- /dev/null +++ b/src/c3a/C3aInstFBegin.java @@ -0,0 +1,23 @@ +package c3a; +import ts.*; + +public class C3aInstFBegin extends C3aInst{ + public TsItemFct val; + public C3aInstFBegin(TsItemFct val, String comment){ + this.val = val; + this.comment = comment; + } + + public String toString(){ + // String s = ""; + // if(this.label != null) + // s = s + this.label; + return this.val.getIdentif() + "\tfbegin\t#" + this.comment; + // return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstFEnd.java b/src/c3a/C3aInstFEnd.java new file mode 100644 index 0000000000000000000000000000000000000000..8e0380f05ae0c72f9b234b8e10c0e2adf7d8676f --- /dev/null +++ b/src/c3a/C3aInstFEnd.java @@ -0,0 +1,21 @@ +package c3a; + +public class C3aInstFEnd extends C3aInst{ + public C3aInstFEnd(String comment){ + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + "fend"; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstJump.java b/src/c3a/C3aInstJump.java new file mode 100644 index 0000000000000000000000000000000000000000..1324e5e43d8545aee99a9ccf0e769f2a7b0ca2ca --- /dev/null +++ b/src/c3a/C3aInstJump.java @@ -0,0 +1,24 @@ +package c3a; + +public class C3aInstJump extends C3aInst{ + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstJump(C3aOperand result, String comment){ + this.result = result; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + "goto " + this.result; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstJumpIfEqual.java b/src/c3a/C3aInstJumpIfEqual.java new file mode 100644 index 0000000000000000000000000000000000000000..98bdb79305249c803e12a07c334ea4337d6958b7 --- /dev/null +++ b/src/c3a/C3aInstJumpIfEqual.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstJumpIfEqual extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand op2; // opérande 2 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstJumpIfEqual(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){ + this.op1 = op1; + this.op2 = op2; + this.result = result; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\tif " + this.op1 + " == " + this.op2 + " goto " + this.result; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstJumpIfLess.java b/src/c3a/C3aInstJumpIfLess.java new file mode 100644 index 0000000000000000000000000000000000000000..a88a20ecc8639fc2d64259e702ca8fe46dd7273b --- /dev/null +++ b/src/c3a/C3aInstJumpIfLess.java @@ -0,0 +1,28 @@ +package c3a; + +public class C3aInstJumpIfLess extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand op2; // opérande 2 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstJumpIfLess(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){ + this.op1 = op1; + this.op2 = op2; + this.result = result; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + "if " + this.op1 + " < " + this.op2 + " goto " + this.result; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstJumpIfNotEqual.java b/src/c3a/C3aInstJumpIfNotEqual.java new file mode 100644 index 0000000000000000000000000000000000000000..06bc8c4a703a42789fa2f04b99acec26d4b320ac --- /dev/null +++ b/src/c3a/C3aInstJumpIfNotEqual.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstJumpIfNotEqual extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand op2; // opérande 2 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstJumpIfNotEqual(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){ + this.op1 = op1; + this.op2 = op2; + this.result = result; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\tif " + this.op1 + " != " + this.op2 + " goto " + this.result; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstMult.java b/src/c3a/C3aInstMult.java new file mode 100644 index 0000000000000000000000000000000000000000..282d20a74c77185e289d4d4d216b113db48746b3 --- /dev/null +++ b/src/c3a/C3aInstMult.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstMult extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand op2; // opérande 2 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstMult(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){ + this.op1 = op1; + this.op2 = op2; + this.result = result; + this.comment = comment; + } + + public String toString(){ + if(this.label != null) + return this.label + "\t" + this.result + " = " + this.op1 + " * " + this.op2 + this.comment; + else + return "\t" + this.result + " = " + this.op1 + " * " + this.op2 + this.comment; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstParam.java b/src/c3a/C3aInstParam.java new file mode 100644 index 0000000000000000000000000000000000000000..44b96e2de53ed787d7338c9ad797ade474b232e3 --- /dev/null +++ b/src/c3a/C3aInstParam.java @@ -0,0 +1,25 @@ +package c3a; + +public class C3aInstParam extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + + public C3aInstParam(C3aOperand op1, String comment){ + this.op1 = op1; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + "param " + this.op1; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstRead.java b/src/c3a/C3aInstRead.java new file mode 100644 index 0000000000000000000000000000000000000000..4586c03f89e52601f3e27cb00db075876ce4a091 --- /dev/null +++ b/src/c3a/C3aInstRead.java @@ -0,0 +1,25 @@ +package c3a; + +public class C3aInstRead extends C3aInst{ + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstRead(C3aOperand result, String comment){ + this.result = result; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + this.result + " = read #" + this.comment; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstReturn.java b/src/c3a/C3aInstReturn.java new file mode 100644 index 0000000000000000000000000000000000000000..48d47a3ca66e6fe9b9505d371176645e6d73b9f3 --- /dev/null +++ b/src/c3a/C3aInstReturn.java @@ -0,0 +1,25 @@ +package c3a; + +public class C3aInstReturn extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + + public C3aInstReturn(C3aOperand op1, String comment){ + this.op1 = op1; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + "ret " + this.op1; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstStop.java b/src/c3a/C3aInstStop.java new file mode 100644 index 0000000000000000000000000000000000000000..12404d552a20d9ee93e29dc4194de6a09d460703 --- /dev/null +++ b/src/c3a/C3aInstStop.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstStop extends C3aInst{ + public C3aOperand returnValue; + + public C3aInstStop(C3aOperand returnValue, String comment){ + this.returnValue = returnValue; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + "stop "; + if(this.returnValue != null) + s = s + this.returnValue; + s = s + this.comment; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} + diff --git a/src/c3a/C3aInstSub.java b/src/c3a/C3aInstSub.java new file mode 100644 index 0000000000000000000000000000000000000000..18a985368f0c27d17add8712ca7ddd042b398c96 --- /dev/null +++ b/src/c3a/C3aInstSub.java @@ -0,0 +1,27 @@ +package c3a; + +public class C3aInstSub extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand op2; // opérande 2 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstSub(C3aOperand op1, C3aOperand op2, C3aOperand result, String comment){ + this.op1 = op1; + this.op2 = op2; + this.result = result; + this.comment = comment; + } + + public String toString(){ + if(this.label != null) + return this.label + "\t" + this.result + " = " + this.op1 + " - " + this.op2 + this.comment; + else + return "\t" + this.result + " = " + this.op1 + " - " + this.op2 + this.comment; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aInstWrite.java b/src/c3a/C3aInstWrite.java new file mode 100644 index 0000000000000000000000000000000000000000..0e1b1a7576b6e2dfe7a52c95950f0f366716d307 --- /dev/null +++ b/src/c3a/C3aInstWrite.java @@ -0,0 +1,26 @@ +package c3a; + +public class C3aInstWrite extends C3aInst{ + public C3aOperand op1; // opérande 1 (ou null) + public C3aOperand result; // résultat ou destination du saut (ou NULL) + + public C3aInstWrite(C3aOperand op1, String comment){ + this.op1 = op1; + this.comment = comment; + } + + public String toString(){ + String s = ""; + if(this.label != null) + s = s + this.label; + s = s + "\t"; + s = s + "write " + this.op1 + "\t" + this.comment; + return s; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } + +} + diff --git a/src/c3a/C3aLabel.java b/src/c3a/C3aLabel.java new file mode 100644 index 0000000000000000000000000000000000000000..f70d1c3eca89af48274a5d9160811dec67d98997 --- /dev/null +++ b/src/c3a/C3aLabel.java @@ -0,0 +1,29 @@ +package c3a; + +public class C3aLabel extends C3aOperand{ + public int number; // numéro de l'étiquette + private int line; // ligne de l'opération correspondant à l'étiquette + // public String name; + + // public C3aLabel(int number, int line, String name){ + public C3aLabel(int number){ + this.number = number; + this.line = 0; + // this.name = name; + } + + public int getNumber(){return this.number;} + public int getLine(){return this.line;} + + public String toString(){return String.valueOf(this.number);} +// public String toString(){return "l" + this.number;} + + public void affect(C3aLabel other) { + this.number = other.number; + this.line = other.line; + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/c3a/C3aOp.java b/src/c3a/C3aOp.java new file mode 100644 index 0000000000000000000000000000000000000000..e03daf69f03f5776343f30f55c6028bf5cc00cc8 --- /dev/null +++ b/src/c3a/C3aOp.java @@ -0,0 +1,24 @@ +package c3a; + +public enum C3aOp{ + arithAdd, + arithSub, + arithMult, + arithDiv, + funcCall, + funcParam, + funcValRet, + funcBegin, + funcEnd, + assign, //affectation et transferts temporaires <-> variables + alloc, // allouer de la place pour variables + jump, + jump_if_less, + jump_if_less_or_equal, + jumpIfEqual, + jump_if_not_equal, + jump_if_greater, + jump_if_greater_or_equal, + sys_read, + sys_write; // lire et écrire (interruptions système) +} diff --git a/src/c3a/C3aOperand.java b/src/c3a/C3aOperand.java new file mode 100644 index 0000000000000000000000000000000000000000..7744c0da123c4b51b25f59eef089c4f16bb27e1d --- /dev/null +++ b/src/c3a/C3aOperand.java @@ -0,0 +1,7 @@ +package c3a; + +public abstract class C3aOperand { + + public abstract <T> T accept(C3aVisitor <T> visitor); + +} diff --git a/src/c3a/C3aTemp.java b/src/c3a/C3aTemp.java new file mode 100644 index 0000000000000000000000000000000000000000..6958c45b43d7823215f39f77d5d2642e5acda957 --- /dev/null +++ b/src/c3a/C3aTemp.java @@ -0,0 +1,16 @@ +package c3a; + +public class C3aTemp extends C3aOperand{ + public int num; + + public C3aTemp(int num){ + this.num = num; + } + + public String toString(){ + return "@" + this.num; + } + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/c3a/C3aVar.java b/src/c3a/C3aVar.java new file mode 100644 index 0000000000000000000000000000000000000000..dcef2c2f3915df288eb0abe466574a1c27234d29 --- /dev/null +++ b/src/c3a/C3aVar.java @@ -0,0 +1,24 @@ +package c3a; +import ts.*; + +public class C3aVar extends C3aOperand{ + public TsItemVar item; + public C3aOperand index; + + public C3aVar(TsItemVar item, C3aOperand index){ + this.item = item; + this.index = index; + } + + public String toString(){ + if(this.index != null) + // return this.item.getIdentif() + "[" + this.item.getTaille() + "]"; + return this.item.getIdentif() + "[" + this.index + "]"; + else + return this.item.getIdentif(); + } + + public <T> T accept(C3aVisitor <T> visitor) { + return visitor.visit(this); + } +} diff --git a/src/c3a/C3aVisitor.java b/src/c3a/C3aVisitor.java new file mode 100644 index 0000000000000000000000000000000000000000..b8f2b96f99869605b801ddd21d33239ac703ae7d --- /dev/null +++ b/src/c3a/C3aVisitor.java @@ -0,0 +1,30 @@ +package c3a; + +public interface C3aVisitor <T> { + public T visit(C3a c3a); + public T visit(C3aInstAdd inst); + public T visit(C3aInstCall inst); + public T visit(C3aInstFBegin inst); + public T visit(C3aInst inst); + public T visit(C3aInstJumpIfLess inst); + public T visit(C3aInstMult inst); + public T visit(C3aInstRead inst); + public T visit(C3aInstSub inst); + public T visit(C3aInstAffect inst); + public T visit(C3aInstDiv inst); + public T visit(C3aInstFEnd inst); + public T visit(C3aInstJumpIfEqual inst); + public T visit(C3aInstJumpIfNotEqual inst); + public T visit(C3aInstJump inst); + public T visit(C3aInstParam inst); + public T visit(C3aInstReturn inst); + public T visit(C3aInstWrite inst); + public T visit(C3aInstStop inst); + + public T visit(C3aConstant oper); + public T visit(C3aBooleanConstant oper); + public T visit(C3aLabel oper); + public T visit(C3aTemp oper); + public T visit(C3aVar oper); + public T visit(C3aFunction oper); +} diff --git a/src/c3a/LoadC3a.java b/src/c3a/LoadC3a.java new file mode 100644 index 0000000000000000000000000000000000000000..c321ea9b5c125cab957ab3f4e97e7cf0bedb99a5 --- /dev/null +++ b/src/c3a/LoadC3a.java @@ -0,0 +1,473 @@ +package c3a; +import c3aParser.analysis.DepthFirstAdapter; +import ts.*; +import c3aParser.lexer.Lexer; +import c3aParser.lexer.LexerException; +import c3aParser.node.*; +import c3aParser.parser.Parser; +import c3aParser.parser.ParserException; +import util.Error; + +import java.io.FileReader; +import java.io.IOException; +import java.io.PushbackReader; + +public class LoadC3a extends DepthFirstAdapter { + private C3a c3a; + private C3aInst inst; + private C3aOperand operand; + private C3aLabel label; + private Ts tableGlobale; + private Ts tableLocale = null; + + public LoadC3a(String c3aFileName, Ts tableGlobale) { + this.tableGlobale = tableGlobale; + PushbackReader fileReader = null; + Parser parser = null; + Start root = null; + try { + fileReader = new PushbackReader(new FileReader(c3aFileName)); + } catch (IOException e) { + System.err.println("cannot open input file"); + e.printStackTrace(); + } + try { + parser = new Parser(new Lexer(fileReader)); + root = parser.parse(); + } catch (ParserException e) { + System.err.println("syntax error"); + e.printStackTrace(); + System.exit(Error.SYNT.code()); + } catch (LexerException e) { + System.err.println("lexical error"); + e.printStackTrace(); + System.exit(Error.LEX.code()); + } catch (IOException e) { + e.printStackTrace(); + } + root.apply(this); + } + + public void defaultIn(Node node) + { + //System.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(Node node) + { + //System.out.println("</" + node.getClass().getSimpleName() + ">"); + } + + public C3a getC3a(){return c3a;} + //prog = listeinst; + @Override + public void caseAProg(AProg node) + { + inAProg(node); + c3a = new C3a(); + if(node.getListeinst() != null) + { + node.getListeinst().apply(this); + } + outAProg(node); + } +//listeinst = {recursif} inst listeinst + @Override + public void caseARecursifListeinst(ARecursifListeinst node) + { + inARecursifListeinst(node); + node.getInst().apply(this); + c3a.ajouteInst(inst); + label = null; + node.getListeinst().apply(this); + outARecursifListeinst(node); + } + +// listeinst = {final} inst + @Override + public void caseAFinalListeinst(AFinalListeinst node) + { + inAFinalListeinst(node); + node.getInst().apply(this); + c3a.ajouteInst(inst); + label = null; + outAFinalListeinst(node); + } + + //add = etiqop [result]:tv aff [op1]:ctv plus [op2]:ctv; + @Override + public void caseAAdd(AAdd node) + { + inAAdd(node); + if(node.getEtiqop() != null) + { + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + } + node.getResult().apply(this); + C3aOperand result = operand; + node.getOp1().apply(this); + C3aOperand op1 = operand; + node.getOp2().apply(this); + C3aOperand op2 = operand; + inst = new C3aInstAdd(op1, op2, result, ""); + outAAdd(node); + } + + //sub = etiqop [result]:tv aff [op1]:ctv moins [op2]:ctv; + @Override + public void caseASub(ASub node) + { + inASub(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getResult().apply(this); + C3aOperand result = operand; + + node.getOp1().apply(this); + C3aOperand op1 = operand; + + node.getOp2().apply(this); + C3aOperand op2 = operand; + + inst = new C3aInstSub(op1, op2, result, ""); + outASub(node); + } + + //mul = etiqop [result]:tv aff [op1]:ctv fois [op2]:ctv; + @Override + public void caseAMul(AMul node) + { + inAMul(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getResult().apply(this); + C3aOperand result = operand; + + node.getOp1().apply(this); + C3aOperand op1 = operand; + + node.getOp2().apply(this); + C3aOperand op2 = operand; + + inst = new C3aInstMult(op1,op2, result, ""); + outAMul(node); + } + + //div = etiqop [result]:tv aff [op1]:ctv divise [op2]:ctv; + @Override + public void caseADiv(ADiv node) + { + inADiv(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getResult().apply(this); + C3aOperand result = operand; + + node.getOp1().apply(this); + C3aOperand op1 = operand; + + node.getOp2().apply(this); + C3aOperand op2 = operand; + + inst = new C3aInstDiv(op1,op2, result, ""); + outADiv(node); + } + + + //istop = etiqop stop ctv; + @Override + public void caseAIstop(AIstop node) + { + inAIstop(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getCtv().apply(this); + C3aOperand op1 = operand; + + inst = new C3aInstStop(op1, ""); + outAIstop(node); + } + +// iwrite = etiqop write ctv; + + @Override + public void caseAIwrite(AIwrite node) + { + inAIwrite(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getCtv().apply(this); + C3aOperand op = operand; + + inst = new C3aInstWrite(op, ""); + outAIwrite(node); + } + + // iread = etiqop [result]:tv aff read; + + @Override + public void caseAIread(AIread node) + { + inAIread(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getResult().apply(this); + C3aOperand result = operand; + + inst = new C3aInstRead(result, ""); + outAIread(node); + } + + // end = etiqop fend; +@Override +public void caseAEnd(AEnd node) +{ + inAEnd(node); + if(node.getEtiqop() != null) + { + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + } + inst = new C3aInstFEnd(""); + outAEnd(node); +} + +// affect = etiqop [result]:tv aff [op1]:ctv; + + @Override + public void caseAAffect(AAffect node) + { + inAAffect(node); + if(node.getEtiqop() != null) + { + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + } + node.getResult().apply(this); + C3aOperand result = operand; + + node.getOp1().apply(this); + C3aOperand op1 = operand; + inst = new C3aInstAffect(op1, result, ""); + outAAffect(node); + } + +// jmpeg = etiqop if [op1]:ctv aff [op2]:ctv goto [result]:constante; +@Override +public void caseAJmpeg(AJmpeg node) +{ + inAJmpeg(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getOp1().apply(this); + C3aOperand op1 = operand; + + node.getOp2().apply(this); + C3aOperand op2 = operand; + + node.getResult().apply(this); + C3aOperand result = operand; + + inst = new C3aInstJumpIfEqual(op1, op2, result, ""); + outAJmpeg(node); +} + +// jmpinf = etiqop if [op1]:ctv inf [op2]:ctv goto [result]:constante; +@Override +public void caseAJmpinf(AJmpinf node) +{ + inAJmpinf(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getOp1().apply(this); + C3aOperand op1 = operand; + + node.getOp2().apply(this); + C3aOperand op2 = operand; + + node.getResult().apply(this); + C3aOperand result = operand; + + inst = new C3aInstJumpIfLess(op1, op2, result, ""); + outAJmpinf(node); +} + +// jmpneg = etiqop if [op1]:ctv noteg [op2]:ctv goto [result]:constante; +@Override +public void caseAJmpneg(AJmpneg node) +{ + inAJmpneg(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getOp1().apply(this); + C3aOperand op1 = operand; + + node.getOp2().apply(this); + C3aOperand op2 = operand; + + node.getResult().apply(this); + C3aOperand result = operand; + + inst = new C3aInstJumpIfNotEqual(op1, op2, result, ""); + outAJmpneg(node); +} + + @Override + public void caseAJmp(AJmp node) + { + inAJmp(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getResult().apply(this); + C3aOperand result = operand; + + inst = new C3aInstJump(result, ""); + outAJmp(node); + } + + + //arg = etiqop param ctv; + @Override + public void caseAArg(AArg node) + { + inAArg(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + + node.getCtv().apply(this); + C3aOperand op1 = operand; + inst = new C3aInstParam(op1, ""); + outAArg(node); + } +//return = etiqop ret ctv; + + @Override + public void caseAReturn(AReturn node) + { + inAReturn(node); + node.getEtiqop().apply(this); + c3a.addLabelToNextInst(label); + node.getCtv().apply(this); + C3aOperand op1 = operand; + inst = new C3aInstReturn(op1, ""); + outAReturn(node); + } + +//temporaire = prefixe_temp constante; + @Override + public void caseATemporaire(ATemporaire node) + { + inATemporaire(node); + int num = Integer.parseInt(node.getNombre().getText()); + if(num >= c3a.getTempCounter()) + c3a.setTempCounter(num + 1); + operand = new C3aTemp(num); + outATemporaire(node); + } + +//constante = nombre; +@Override +public void caseAConstante(AConstante node) { + inAConstante(node); + int num = Integer.parseInt(node.getNombre().getText()); + operand = new C3aConstant(num); + outAConstante(node); +} + +@Override + public void caseAVideEtiqop(AVideEtiqop node) + { + inAVideEtiqop(node); + outAVideEtiqop(node); + } + //etiqop = {cte} constante; + @Override + public void caseACteEtiqop(ACteEtiqop node) + { + inACteEtiqop(node); + int num = Integer.parseInt(node.getNombre().getText()); + this.label = new C3aLabel(num); + if (num >= c3a.getLabelCounter()) + c3a.setLableCounter(num + 1); + outACteEtiqop(node); + } + +// variable = {scalaire} identif + @Override + public void caseAScalaireVariable(AScalaireVariable node) + { + inAScalaireVariable(node); + String identif = node.getIdentif().getText(); + TsItemVarSimple tsItemVarSimple = null; + if(tableLocale != null) + tsItemVarSimple = (TsItemVarSimple) tableLocale.getVar(identif); + if(tsItemVarSimple == null) + tsItemVarSimple = (TsItemVarSimple) tableGlobale.getVar(identif); + operand = new C3aVar(tsItemVarSimple, null); + outAScalaireVariable(node); + } + +// variable = {tab} identif co ctv cf + @Override + public void caseATabVariable(ATabVariable node) + { + inATabVariable(node); + String identif = node.getIdentif().getText(); + TsItemVarTab tsItemVarTab = null; + if(tableLocale != null) + tsItemVarTab = (TsItemVarTab) tableLocale.getVar(identif); + if(tsItemVarTab == null) + tsItemVarTab = (TsItemVarTab) tableGlobale.getVar(identif); + node.getCtv().apply(this); + C3aOperand index = operand; + operand = new C3aVar(tsItemVarTab, index); + outATabVariable(node); + } + + + @Override + public void caseABegin(ABegin node) + { + inABegin(node); + + String functionName = node.getIdentif().getText(); + TsItemFct tsItemFct = tableGlobale.getFct(functionName); + tableLocale = tsItemFct.getTable(); + inst = new C3aInstFBegin(tsItemFct, ""); + outABegin(node); + } + + //fcall = etiqop [result]:tv aff call identif; + @Override + public void caseAFcall(AFcall node) + { + inAFcall(node); + if(node.getEtiqop() != null) + { + node.getEtiqop().apply(this); + } + node.getResult().apply(this); + C3aOperand result = operand; + + C3aFunction op1 = new C3aFunction(tableGlobale.getFct(node.getIdentif().getText())); + inst = new C3aInstCall(op1, result, ""); + + outAFcall(node); + } + + +} + + + diff --git a/src/c3a/Sa2c3a.java b/src/c3a/Sa2c3a.java new file mode 100644 index 0000000000000000000000000000000000000000..8e1a01f8920f5c383c6ec223d7a1bdfb1df11b55 --- /dev/null +++ b/src/c3a/Sa2c3a.java @@ -0,0 +1,49 @@ +package c3a; +import ts.*; +import sa.*; + + +public class Sa2c3a extends SaDepthFirstVisitor <C3aOperand> { + private C3a c3a; + int indentation; + public C3a getC3a(){return this.c3a;} + + public Sa2c3a(SaNode root, Ts tableGlobale){ + c3a = new C3a(); + C3aTemp result = c3a.newTemp(); + C3aFunction fct = new C3aFunction(tableGlobale.getFct("main")); + c3a.ajouteInst(new C3aInstCall(fct, result, "")); + c3a.ajouteInst(new C3aInstStop(result, "")); + indentation = 0; + } + + public void defaultIn(SaNode node) + { + //for(int i = 0; i < indentation; i++){System.out.print(" ");} + //indentation++; + //System.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(SaNode node) + { + //indentation--; + // for(int i = 0; i < indentation; i++){System.out.print(" ");} + // System.out.println("</" + node.getClass().getSimpleName() + ">"); + } + + + // EXP -> op2 EXP EXP + public C3aOperand visit(SaExpAdd node) throws Exception + { + defaultIn(node); + C3aOperand op1 = node.getOp1().accept(this); + C3aOperand op2 = node.getOp2().accept(this); + C3aOperand result = c3a.newTemp(); + + c3a.ajouteInst(new C3aInstAdd(op1, op2, result, "")); + defaultOut(node); + return result; + } + + +} diff --git a/src/fg/Fg.java b/src/fg/Fg.java new file mode 100644 index 0000000000000000000000000000000000000000..c306fd59e2633583fd7a07b50244db85c790c57b --- /dev/null +++ b/src/fg/Fg.java @@ -0,0 +1,87 @@ +package fg; +import nasm.*; +import util.graph.*; +import java.util.*; +import java.io.*; + +public class Fg implements NasmVisitor <Void> { + public Nasm nasm; + public Graph graph; + Map< NasmInst, Node> inst2Node; + Map< Node, NasmInst> node2Inst; + Map< String, NasmInst> label2Inst; + + public Fg(Nasm nasm){ + this.nasm = nasm; + this.inst2Node = new HashMap< NasmInst, Node>(); + this.node2Inst = new HashMap< Node, NasmInst>(); + this.label2Inst = new HashMap< String, NasmInst>(); + this.graph = new Graph(); + } + + public void affiche(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".fg"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + + for(NasmInst nasmInst : nasm.sectionText){ + Node n = this.inst2Node.get(nasmInst); + out.print(n + " : ( "); + for(NodeList q=n.succ(); q!=null; q=q.tail) { + out.print(q.head.toString()); + out.print(" "); + } + out.println(")\t" + nasmInst); + } + + } + + public Void visit(NasmAdd inst){return null;} + public Void visit(NasmCall inst){return null;} + public Void visit(NasmDiv inst){return null;} + public Void visit(NasmJe inst){return null;} + public Void visit(NasmJle inst){return null;} + public Void visit(NasmJne inst){return null;} + public Void visit(NasmMul inst){return null;} + public Void visit(NasmOr inst){return null;} + public Void visit(NasmCmp inst){return null;} + public Void visit(NasmInst inst){return null;} + public Void visit(NasmJge inst){return null;} + public Void visit(NasmJl inst){return null;} + public Void visit(NasmNot inst){return null;} + public Void visit(NasmPop inst){return null;} + public Void visit(NasmRet inst){return null;} + public Void visit(NasmXor inst){return null;} + public Void visit(NasmAnd inst){return null;} + public Void visit(NasmJg inst){return null;} + public Void visit(NasmJmp inst){return null;} + public Void visit(NasmMov inst){return null;} + public Void visit(NasmPush inst){return null;} + public Void visit(NasmSub inst){return null;} + public Void visit(NasmEmpty inst){return null;} + public Void visit(NasmInt inst){return null;} + public Void visit(NasmAddress operand){return null;} + public Void visit(NasmConstant operand){return null;} + public Void visit(NasmLabel operand){return null;} + public Void visit(NasmRegister operand){return null;} + public Void visit(NasmResb pseudoInst){return null;} + public Void visit(NasmResw pseudoInst){return null;} + public Void visit(NasmResd pseudoInst){return null;} + public Void visit(NasmResq pseudoInst){return null;} + public Void visit(NasmRest pseudoInst){return null;} + public Void visit(NasmExpPlus exp){return null;} + public Void visit(NasmExpMinus exp){return null;} + public Void visit(NasmExpTimes exp){return null;} + public Void visit(NasmExp exp){return null;} +} diff --git a/src/fg/FgSolution.java b/src/fg/FgSolution.java new file mode 100644 index 0000000000000000000000000000000000000000..0970759509bbf4365786cb26710f8aecbd3766b0 --- /dev/null +++ b/src/fg/FgSolution.java @@ -0,0 +1,51 @@ +package fg; +import util.graph.*; +import nasm.*; +import util.intset.*; +import java.io.*; +import java.util.*; + +public class FgSolution{ + int iterNum = 0; + public Nasm nasm; + Fg fg; + public Map< NasmInst, IntSet> use; + public Map< NasmInst, IntSet> def; + public Map< NasmInst, IntSet> in; + public Map< NasmInst, IntSet> out; + + public FgSolution(Nasm nasm, Fg fg){ + this.nasm = nasm; + this.fg = fg; + this.use = new HashMap< NasmInst, IntSet>(); + this.def = new HashMap< NasmInst, IntSet>(); + this.in = new HashMap< NasmInst, IntSet>(); + this.out = new HashMap< NasmInst, IntSet>(); + } + + public void affiche(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".fgs"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + + out.println("iter num = " + iterNum); + for(NasmInst nasmInst : this.nasm.sectionText){ + out.println("use = "+ this.use.get(nasmInst) + " def = "+ this.def.get(nasmInst) + "\tin = " + this.in.get(nasmInst) + "\t \tout = " + this.out.get(nasmInst) + "\t \t" + nasmInst); + } + + } + + + +} diff --git a/src/ig/Ig.java b/src/ig/Ig.java new file mode 100644 index 0000000000000000000000000000000000000000..eaf4886ff148177147648092d82af66a28a03af4 --- /dev/null +++ b/src/ig/Ig.java @@ -0,0 +1,61 @@ +package ig; + +import fg.*; +import nasm.*; +import util.graph.*; +import util.intset.*; +import java.util.*; +import java.io.*; + +public class Ig { + public Graph graph; + public FgSolution fgs; + public int regNb; + public Nasm nasm; + public Node int2Node[]; + + + public Ig(FgSolution fgs){ + this.fgs = fgs; + this.graph = new Graph(); + this.nasm = fgs.nasm; + this.regNb = this.nasm.getTempCounter(); + this.int2Node = new Node[regNb]; + this.build(); + } + + public void build(){ + } + + public void affiche(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".ig"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + + for(int i = 0; i < regNb; i++){ + Node n = this.int2Node[i]; + out.print(n + " : ( "); + for(NodeList q=n.succ(); q!=null; q=q.tail) { + out.print(q.head.toString()); + out.print(" "); + } + out.println(")"); + } + } +} + + + + + diff --git a/src/l.cfg b/src/l.cfg new file mode 100644 index 0000000000000000000000000000000000000000..5159f484cf0ea7172ce62b4aad5a0aaf3ab18347 --- /dev/null +++ b/src/l.cfg @@ -0,0 +1,32 @@ +Package lParser; + +Helpers + +lettre = [['a' .. 'z'] + ['A' .. 'Z']]; +chiffre = ['0' .. '9']; +alpha = [lettre + ['_' + '$']]; +alphanum = [lettre + chiffre]; + +Tokens + +espaces = (' ' | 13 | 10)+; +commentaire= '#' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13); +plus = '+'; +nombre = chiffre+; + + +Ignored Tokens + +espaces, commentaire; + +Productions + +// l'axiome + +programme = exp ; + +exp = + {plus} exp plus nombre | + {nb} nombre ; + + diff --git a/src/nasm.cfg b/src/nasm.cfg new file mode 100644 index 0000000000000000000000000000000000000000..cbc3812ff198b459a7b8ef13cd583983504283d9 --- /dev/null +++ b/src/nasm.cfg @@ -0,0 +1,210 @@ +Package nasmParser; + +Helpers + +letter = [['a' .. 'z'] + ['A' .. 'Z']]; +digit = ['0' .. '9']; +alpha = [letter + ['_' + '$']]; +alphanum = [letter + digit]; + +Tokens + +spaces = (' ' | 13 | 10 | 9)+; +comment= ';' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13); + +plus = '+'; +minus = '-'; +times = '*'; +brackopen = '['; +brackclose = ']'; +semicol = ':'; +comma = ','; +quote = '''; +dot = '.'; +percentage = '%'; +byte = 'byte'; +word = 'word'; +dword = 'dword'; +prefix_register = '@'; + +inc = 'include'; +section = 'section'; + +data = '.data'; +definebyte = 'db'; +defineword = 'dw'; +definedoubleword = 'dd'; +definequadword = 'dq'; +definetenbytes = 'dt'; + +bss = '.bss'; +reservebyte = 'resb'; +reserveword = 'resw'; +reservedoubleword = 'resd'; +reservequadword = 'resq'; +reservetenbytes = 'rest'; + +text = '.text'; + +global = 'global'; + +mov = 'mov'; +push = 'push'; +pop = 'pop'; +add = 'add'; +sub = 'sub'; +imul = 'imul'; +idiv = 'idiv'; +and = 'and'; +or = 'or'; +xor = 'xor'; +not = 'not'; +cmp = 'cmp'; +jmp = 'jmp'; +je = 'je'; +jne = 'jne'; +jg = 'jg'; +jge = 'jge'; +jl = 'jl'; +jle = 'jle'; +call = 'call'; +ret = 'ret'; +int = 'int 0x80'; + +eax = 'eax'; +ebx = 'ebx'; +ecx = 'ecx'; +edx = 'edx'; +ebp = 'ebp'; +esp = 'esp'; + +number = digit+; + +id = alpha alphanum*; + +Ignored Tokens + +spaces, comment; + +Productions + +prog = linclude secdata secbss sectext; + +linclude = {rec} include linclude + | {empty}; + +include = percentage inc [open]: quote filename [close]: quote ; + +filename = {simple} label + | {complex} [prefix]: label dot [suffix]: label + ; + +secdata = {nonempty} section data lconst + | {empty} + ; + +lconst = {rec} const lconst + | {empty} ; + +const = {db} label definebyte numconst + | {dw} label defineword numconst + | {dd} label definedoubleword numconst + | {dq} label definequadword numconst + | {dt} label definetenbytes numconst + ; + +secbss = {nonempty} section bss lvar + | {empty} + ; + +lvar = {rec} var lvar + | {empty} + ; + +var = {resb} label semicol reservebyte number + | {resw} label semicol reserveword number + | {resd} label semicol reservedoubleword number + | {resq} label semicol reservequadword number + | {rest} label semicol reservetenbytes number + ; + +sectext = section text lglobal linst; + +lglobal = {rec} global label lglobal + | {empty} + ; + +linst = {rec} inst linst | + {last} inst + ; + +inst = {mov} oplabel mov ar comma acr + | {push} oplabel push acr + | {pop} oplabel pop ar + | {add} oplabel add ar comma acr + | {sub} oplabel sub ar comma acr + | {imul} oplabel imul ar comma acr + | {idiv} oplabel idiv ar + | {and} oplabel and ar comma acr + | {or} oplabel or ar comma acr + | {xor} oplabel xor ar comma acr + | {not} oplabel not ar + | {cmp} oplabel cmp ar comma acr + | {jmp} oplabel jmp label + | {je} oplabel je label + | {jne} oplabel jne label + | {jg} oplabel jg label + | {jge} oplabel jge label + | {jl} oplabel jl label + | {call} oplabel call label + | {ret} oplabel ret + | {inter} oplabel int + ; + +acr = {address} address + | {numconst} numconst + | {register} register + ; + +ar = {address} address + | {register} register + ; + +address = opsizeof brackopen exp brackclose; + +opsizeof = {byte} byte + | {word} word + | {dword} dword + | {empty} + ; + +exp = {plus} exp plus exp1 + | {minus} exp minus exp1 + | {next} exp1 + ; + +exp1 = {times} exp1 times exp2 + | {next} exp2 + ; + +exp2 = {label} label + | {numconst} numconst + | {register} register + ; + +numconst = number; + +register = {temp} prefix_register number + | {eax} eax + | {ebx} ebx + | {ecx} ecx + | {edx} edx + | {ebp} ebp + | {esp} esp + ; + +oplabel = {label} label semicol + | {empty} + ; + +label = id; diff --git a/src/nasm/C3a2nasm.java b/src/nasm/C3a2nasm.java new file mode 100644 index 0000000000000000000000000000000000000000..de33f5cf53abc9f77d42922fa678d27e59974e96 --- /dev/null +++ b/src/nasm/C3a2nasm.java @@ -0,0 +1,59 @@ +package nasm; +import java.util.*; +import ts.*; +import c3a.*; + +public class C3a2nasm implements C3aVisitor <NasmOperand> { + private C3a c3a; + private Nasm nasm; + private Ts tableGlobale; + private TsItemFct currentFct; + private NasmRegister esp; + private NasmRegister ebp; + + + public C3a2nasm(C3a c3a, Ts tableGlobale){ + this.c3a = c3a; + nasm = new Nasm(tableGlobale); + nasm.setTempCounter(c3a.getTempCounter()); + + this.tableGlobale = tableGlobale; + this.currentFct = null; + esp = new NasmRegister(-1); + esp.colorRegister(Nasm.REG_ESP); + + ebp = new NasmRegister(-1); + ebp.colorRegister(Nasm.REG_EBP); + } + + public Nasm getNasm(){return nasm;} + + + public NasmOperand visit(C3a c3a){return null;} + public NasmOperand visit(C3aInstAdd inst){return null;} + public NasmOperand visit(C3aInstCall inst){return null;} + public NasmOperand visit(C3aInstFBegin inst){return null;} + public NasmOperand visit(C3aInst inst){return null;} + public NasmOperand visit(C3aInstJumpIfLess inst){return null;} + public NasmOperand visit(C3aInstMult inst){return null;} + public NasmOperand visit(C3aInstRead inst){return null;} + public NasmOperand visit(C3aInstSub inst){return null;} + public NasmOperand visit(C3aInstAffect inst){return null;} + public NasmOperand visit(C3aInstDiv inst){return null;} + public NasmOperand visit(C3aInstFEnd inst){return null;} + public NasmOperand visit(C3aInstJumpIfEqual inst){return null;} + public NasmOperand visit(C3aInstJumpIfNotEqual inst){return null;} + public NasmOperand visit(C3aInstJump inst){return null;} + public NasmOperand visit(C3aInstParam inst){return null;} + public NasmOperand visit(C3aInstReturn inst){return null;} + public NasmOperand visit(C3aInstWrite inst){return null;} + public NasmOperand visit(C3aInstStop inst){return null;} + + public NasmOperand visit(C3aConstant oper){return null;} + public NasmOperand visit(C3aBooleanConstant oper){return null;} + public NasmOperand visit(C3aLabel oper){return null;} + public NasmOperand visit(C3aTemp oper){return null;} + public NasmOperand visit(C3aVar oper){return null;} + public NasmOperand visit(C3aFunction oper){return null;} + +} diff --git a/src/nasm/LoadNasm.java b/src/nasm/LoadNasm.java new file mode 100644 index 0000000000000000000000000000000000000000..e68802c4e5f0b303877c33d8fc67a565c183b92a --- /dev/null +++ b/src/nasm/LoadNasm.java @@ -0,0 +1,1117 @@ +package nasm; +import nasmParser.analysis.DepthFirstAdapter; +import nasmParser.lexer.Lexer; +import nasmParser.lexer.LexerException; +import nasmParser.node.*; +import nasmParser.parser.Parser; +import nasmParser.parser.ParserException; +//import sc.analysis.DepthFirstAdapter; +import util.Error; + +import java.io.FileReader; +import java.io.IOException; +import java.io.PushbackReader; + +public class LoadNasm extends DepthFirstAdapter { + private Nasm nasm; + private NasmInst inst; + private NasmPseudoInst pseudoInst; + private NasmOperand operand; + private NasmLabel label; + private NasmExp exp; + private NasmSize size; + public LoadNasm(String nasmFileName) { + nasm = new Nasm(); + PushbackReader fileReader = null; + Parser parser = null; + Start root = null; + try { + fileReader = new PushbackReader(new FileReader(nasmFileName)); + } catch (IOException e) { + System.err.println("cannot open input file"); + e.printStackTrace(); + } + try { + parser = new Parser(new Lexer(fileReader)); + root = parser.parse(); + } catch (ParserException e) { + System.err.println("syntax error"); + e.printStackTrace(); + System.exit(Error.SYNT.code()); + } catch (LexerException e) { + System.err.println("lexical error"); + e.printStackTrace(); + System.exit(Error.LEX.code()); + } catch (IOException e) { + e.printStackTrace(); + } + root.apply(this); + } + + public void defaultIn(Node node) + { + // System.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(Node node) + { + // System.out.println("</" + node.getClass().getSimpleName() + ">"); + } + + public Nasm getNasm(){return nasm;} + + + // prog = linclude secdata secbss sectext + @Override + public void caseAProg(AProg node) + { + inAProg(node); + if(node.getLinclude() != null) + { + node.getLinclude().apply(this); + } + if(node.getSecdata() != null) + { + node.getSecdata().apply(this); + } + if(node.getSecbss() != null) + { + node.getSecbss().apply(this); + } + if(node.getSectext() != null) + { + node.getSectext().apply(this); + } + outAProg(node); + } + + // linclude = {rec} include linclude + @Override + public void caseARecLinclude(ARecLinclude node) + { + inARecLinclude(node); + if(node.getInclude() != null) + { + node.getInclude().apply(this); + } + if(node.getLinclude() != null) + { + node.getLinclude().apply(this); + } + outARecLinclude(node); + } + + // linclude = {empty} + @Override + public void caseAEmptyLinclude(AEmptyLinclude node) + { + inAEmptyLinclude(node); + outAEmptyLinclude(node); + } + + // include = percentage inc [open]: quote filename [close]: quote + @Override + public void caseAInclude(AInclude node) + { + inAInclude(node); + if(node.getPercentage() != null) + { + node.getPercentage().apply(this); + } + if(node.getInc() != null) + { + node.getInc().apply(this); + } + if(node.getOpen() != null) + { + node.getOpen().apply(this); + } + if(node.getFilename() != null) + { + node.getFilename().apply(this); + } + if(node.getClose() != null) + { + node.getClose().apply(this); + } + outAInclude(node); + } + + // filename = {simple} label + @Override + public void caseASimpleFilename(ASimpleFilename node) + { + inASimpleFilename(node); + if(node.getLabel() != null) + { + node.getLabel().apply(this); + } + outASimpleFilename(node); + } + + // filename = {complex} [prefix]: label dot [suffix]: label + @Override + public void caseAComplexFilename(AComplexFilename node) + { + inAComplexFilename(node); + if(node.getPrefix() != null) + { + node.getPrefix().apply(this); + } + if(node.getDot() != null) + { + node.getDot().apply(this); + } + if(node.getSuffix() != null) + { + node.getSuffix().apply(this); + } + outAComplexFilename(node); + } + + // secdata = {nonempty} section data lconst + @Override + public void caseANonemptySecdata(ANonemptySecdata node) + { + inANonemptySecdata(node); + if(node.getSection() != null) + { + node.getSection().apply(this); + } + if(node.getData() != null) + { + node.getData().apply(this); + } + if(node.getLconst() != null) + { + node.getLconst().apply(this); + } + outANonemptySecdata(node); + } + + // secdata = {empty} + @Override + public void caseAEmptySecdata(AEmptySecdata node) + { + inAEmptySecdata(node); + outAEmptySecdata(node); + } + + // lconst = {rec} const lconst + @Override + public void caseARecLconst(ARecLconst node) + { + inARecLconst(node); + if(node.getConst() != null) + { + node.getConst().apply(this); + } + if(node.getLconst() != null) + { + node.getLconst().apply(this); + } + outARecLconst(node); + } + + + // lconst = {empty} + @Override + public void caseAEmptyLconst(AEmptyLconst node) + { + inAEmptyLconst(node); + outAEmptyLconst(node); + } + + // const = {db} label definebyte numconst + @Override + public void caseADbConst(ADbConst node) + { + inADbConst(node); + if(node.getLabel() != null) + { + node.getLabel().apply(this); + } + if(node.getDefinebyte() != null) + { + node.getDefinebyte().apply(this); + } + if(node.getNumconst() != null) + { + node.getNumconst().apply(this); + } + outADbConst(node); + } + + // const = {dw} label defineword numconst + @Override + public void caseADwConst(ADwConst node) + { + inADwConst(node); + if(node.getLabel() != null) + { + node.getLabel().apply(this); + } + if(node.getDefineword() != null) + { + node.getDefineword().apply(this); + } + if(node.getNumconst() != null) + { + node.getNumconst().apply(this); + } + outADwConst(node); + } + + // const = {dd} label definedoubleword numconst + @Override + public void caseADdConst(ADdConst node) + { + inADdConst(node); + if(node.getLabel() != null) + { + node.getLabel().apply(this); + } + if(node.getDefinedoubleword() != null) + { + node.getDefinedoubleword().apply(this); + } + if(node.getNumconst() != null) + { + node.getNumconst().apply(this); + } + outADdConst(node); + } + // const = {dq} label definequadword numconst + @Override + public void caseADqConst(ADqConst node) + { + inADqConst(node); + if(node.getLabel() != null) + { + node.getLabel().apply(this); + } + if(node.getDefinequadword() != null) + { + node.getDefinequadword().apply(this); + } + if(node.getNumconst() != null) + { + node.getNumconst().apply(this); + } + outADqConst(node); + } + // const = {dt} label definetenbytes numconst + @Override + public void caseADtConst(ADtConst node) + { + inADtConst(node); + if(node.getLabel() != null) + { + node.getLabel().apply(this); + } + if(node.getDefinetenbytes() != null) + { + node.getDefinetenbytes().apply(this); + } + if(node.getNumconst() != null) + { + node.getNumconst().apply(this); + } + outADtConst(node); + } + + + // secbss = {nonempty} section bss lvar + @Override + public void caseANonemptySecbss(ANonemptySecbss node) + { + inANonemptySecbss(node); + if(node.getSection() != null) + { + node.getSection().apply(this); + } + if(node.getBss() != null) + { + node.getBss().apply(this); + } + if(node.getLvar() != null) + { + node.getLvar().apply(this); + } + outANonemptySecbss(node); + } + // secbss = {empty} + @Override + public void caseAEmptySecbss(AEmptySecbss node) + { + inAEmptySecbss(node); + outAEmptySecbss(node); + } + + // lvar = {rec} var lvar + @Override + public void caseARecLvar(ARecLvar node) + { + inARecLvar(node); + node.getVar().apply(this); + nasm.ajoutePseudoInst(pseudoInst); + node.getLvar().apply(this); + outARecLvar(node); + } + // lvar = {empty} + @Override + public void caseAEmptyLvar(AEmptyLvar node) + { + inAEmptyLvar(node); + outAEmptyLvar(node); + } + + // var = {resb} label reservebyte number + @Override + public void caseAResbVar(AResbVar node) + { + inAResbVar(node); + node.getLabel().apply(this); + + int nb = Integer.parseInt(node.getNumber().getText()); + pseudoInst = new NasmResb(label,nb,""); + outAResbVar(node); + } + // var = {resw} label reserveword number + @Override + public void caseAReswVar(AReswVar node) + { + inAReswVar(node); + node.getLabel().apply(this); + int nb = Integer.parseInt(node.getNumber().getText()); + pseudoInst = new NasmResw(label,nb,""); + outAReswVar(node); + } + // var = {resd} label reservedoubleword number + @Override + public void caseAResdVar(AResdVar node) + { + inAResdVar(node); + node.getLabel().apply(this); + int nb = Integer.parseInt(node.getNumber().getText()); + pseudoInst = new NasmResd(label,nb,""); + outAResdVar(node); + } + // var = {resq} label reservequadword number + @Override + public void caseAResqVar(AResqVar node) + { + inAResqVar(node); + node.getLabel().apply(this); + int nb = Integer.parseInt(node.getNumber().getText()); + pseudoInst = new NasmResq(label,nb,""); + outAResqVar(node); + } + // var = {rest} label reservetenbytes number + @Override + public void caseARestVar(ARestVar node) + { + inARestVar(node); + node.getLabel().apply(this); + int nb = Integer.parseInt(node.getNumber().getText()); + pseudoInst = new NasmRest(label,nb,""); + outARestVar(node); + } + + // sectext = section text lglobal linst + ////////////////////// + @Override + public void caseASectext(ASectext node) + { + inASectext(node); + if(node.getSection() != null) + { + node.getSection().apply(this); + } + if(node.getText() != null) + { + node.getText().apply(this); + } + if(node.getLglobal() != null) + { + node.getLglobal().apply(this); + } + if(node.getLinst() != null) + { + node.getLinst().apply(this); + } + outASectext(node); + } + + // lglobal = {rec} global label lglobal + @Override + public void caseARecLglobal(ARecLglobal node) + { + inARecLglobal(node); + if(node.getGlobal() != null) + { + node.getGlobal().apply(this); + } + if(node.getLabel() != null) + { + node.getLabel().apply(this); + } + if(node.getLglobal() != null) + { + node.getLglobal().apply(this); + } + outARecLglobal(node); + } + // lglobal = {empty} + @Override + public void caseAEmptyLglobal(AEmptyLglobal node) + { + inAEmptyLglobal(node); + outAEmptyLglobal(node); + } + + + // linst = {rec} inst linst + @Override + public void caseARecLinst(ARecLinst node) + { + inARecLinst(node); + node.getInst().apply(this); + nasm.ajouteInst(inst); + label = null; + exp = null; + size = null; + operand = null; + + node.getLinst().apply(this); + outARecLinst(node); + } + + // linst = {last} inst + @Override + public void caseALastLinst(ALastLinst node) + { + inALastLinst(node); + node.getInst().apply(this); + nasm.ajouteInst(inst); + label = null; + exp = null; + size = null; + operand = null; + outALastLinst(node); + } + + + // inst = {mov} oplabel mov ar comma acr + @Override + public void caseAMovInst(AMovInst node) + { + inAMovInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + + node.getAcr().apply(this); + NasmOperand source = operand; + + inst = new NasmMov(lineLabel, destination, source, ""); + outAMovInst(node); + } + + // inst = {push} oplabel push acr + @Override + public void caseAPushInst(APushInst node) + { + inAPushInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAcr().apply(this); + NasmOperand source = operand; + inst = new NasmPush(lineLabel, source, ""); + outAPushInst(node); + } + + // inst = {pop} oplabel pop ar + @Override + public void caseAPopInst(APopInst node) + { + inAPopInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + + node.getAr().apply(this); + NasmOperand destination = operand; + inst = new NasmPop(lineLabel, destination, ""); + outAPopInst(node); + } + + // inst = {add} oplabel add ar comma acr + @Override + public void caseAAddInst(AAddInst node) + { + inAAddInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + node.getAcr().apply(this); + NasmOperand source = operand; + inst = new NasmAdd(lineLabel, destination, source, ""); + outAAddInst(node); + } + + // inst = {sub} oplabel sub ar comma acr + @Override + public void caseASubInst(ASubInst node) + { + inASubInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + node.getAcr().apply(this); + NasmOperand source = operand; + inst = new NasmSub(lineLabel, destination, source, ""); + outASubInst(node); + } + + // inst = {imul} oplabel imul ar comma acr + @Override + public void caseAImulInst(AImulInst node) + { + inAImulInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + + node.getAr().apply(this); + NasmOperand destination = operand; + node.getAcr().apply(this); + NasmOperand source = operand; + inst = new NasmMul(lineLabel, destination, source, ""); + outAImulInst(node); + } + + // inst = {idiv} oplabel idiv ar + @Override + public void caseAIdivInst(AIdivInst node) + { + inAIdivInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand source = operand; + inst = new NasmDiv(lineLabel, source, ""); + outAIdivInst(node); + } + + // inst = {and} oplabel and ar comma acr + @Override + public void caseAAndInst(AAndInst node) + { + inAAndInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + node.getAcr().apply(this); + NasmOperand source = label; + inst = new NasmOr(lineLabel, destination, source, ""); + outAAndInst(node); + } + + // inst = {or} oplabel or ar comma acr + @Override + public void caseAOrInst(AOrInst node) + { + inAOrInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + node.getAcr().apply(this); + NasmOperand source = operand; + inst = new NasmOr(lineLabel, destination, source, ""); + outAOrInst(node); + } + + // inst = {xor} oplabel xor ar comma acr + @Override + public void caseAXorInst(AXorInst node) + { + inAXorInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + node.getAcr().apply(this); + NasmOperand source = operand; + inst = new NasmXor(lineLabel, destination, source, ""); + outAXorInst(node); + } + + // inst = {not} oplabel not ar + @Override + public void caseANotInst(ANotInst node) + { + inANotInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + inst = new NasmNot(lineLabel, destination, ""); + outANotInst(node); + } + + // inst = {cmp} oplabel cmp ar comma acr + @Override + public void caseACmpInst(ACmpInst node) + { + inACmpInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getAr().apply(this); + NasmOperand destination = operand; + node.getAcr().apply(this); + NasmOperand source = operand; + inst = new NasmCmp(lineLabel, destination, source, ""); + outACmpInst(node); + } + + // inst = {jmp} oplabel jmp label + @Override + public void caseAJmpInst(AJmpInst node) + { + inAJmpInst(node); + node.getOplabel().apply(this); + NasmOperand lineLabel = label; + node.getLabel().apply(this); + NasmOperand jumpTo = label; + inst = new NasmJmp(lineLabel, jumpTo, ""); + outAJmpInst(node); + } + + // inst = {je} oplabel je label + @Override + public void caseAJeInst(AJeInst node) + { + inAJeInst(node); + node.getOplabel().apply(this); + NasmOperand lineLabel = label; + node.getLabel().apply(this); + NasmOperand jumpTo = label; + inst = new NasmJe(lineLabel, jumpTo, ""); + outAJeInst(node); + } + + // inst = {jne} oplabel jne label + @Override + public void caseAJneInst(AJneInst node) + { + inAJneInst(node); + node.getOplabel().apply(this); + NasmOperand lineLabel = label; + node.getLabel().apply(this); + NasmOperand jumpTo = label; + inst = new NasmJne(lineLabel, jumpTo, ""); + } + + // inst = {jg} oplabel jg label + @Override + public void caseAJgInst(AJgInst node) + { + inAJgInst(node); + node.getOplabel().apply(this); + NasmOperand lineLabel = label; + + node.getLabel().apply(this); + NasmOperand jumpTo = label; + inst = new NasmJg(lineLabel, jumpTo, ""); + outAJgInst(node); + } + + // inst = {jge} oplabel jge label + @Override + public void caseAJgeInst(AJgeInst node) + { + inAJgeInst(node); + node.getOplabel().apply(this); + NasmOperand lineLabel = label; + node.getLabel().apply(this); + NasmOperand jumpTo = label; + inst = new NasmJge(lineLabel, jumpTo, ""); + outAJgeInst(node); + } + + // inst = {jl} oplabel jl label + @Override + public void caseAJlInst(AJlInst node) + { + inAJlInst(node); + node.getOplabel().apply(this); + NasmOperand lineLabel = label; + node.getLabel().apply(this); + NasmOperand jumpTo = label; + inst = new NasmJl(lineLabel, jumpTo, ""); + outAJlInst(node); + } + + // inst = {call} oplabel call label + @Override + public void caseACallInst(ACallInst node) + { + inACallInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + node.getLabel().apply(this); + NasmOperand jumpTo = label; + inst = new NasmCall(lineLabel, jumpTo, ""); + outACallInst(node); + } + + // inst = {ret} oplabel ret + @Override + public void caseARetInst(ARetInst node) + { + inARetInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + inst = new NasmRet(lineLabel, ""); + outARetInst(node); + } + + // inst = {inter} oplabel int + @Override + public void caseAInterInst(AInterInst node) + { + inAInterInst(node); + node.getOplabel().apply(this); + NasmLabel lineLabel = label; + inst = new NasmInt(lineLabel, ""); + outAInterInst(node); + } + + // acr = {address} address + @Override + public void caseAAddressAcr(AAddressAcr node) + { + inAAddressAcr(node); + if(node.getAddress() != null) + { + node.getAddress().apply(this); + } + outAAddressAcr(node); + } + + // acr = {numconst} numconst + @Override + public void caseANumconstAcr(ANumconstAcr node) + { + inANumconstAcr(node); + if(node.getNumconst() != null) + { + node.getNumconst().apply(this); + } + outANumconstAcr(node); + } + + // acr = {register} register + @Override + public void caseARegisterAcr(ARegisterAcr node) + { + inARegisterAcr(node); + if(node.getRegister() != null) + { + node.getRegister().apply(this); + } + outARegisterAcr(node); + } + + + // ar = {address} address + @Override + public void caseAAddressAr(AAddressAr node) + { + inAAddressAr(node); + if(node.getAddress() != null) + { + node.getAddress().apply(this); + } + outAAddressAr(node); + } + + // ar = {register} register + @Override + public void caseARegisterAr(ARegisterAr node) + { + inARegisterAr(node); + if(node.getRegister() != null) + { + node.getRegister().apply(this); + } + outARegisterAr(node); + } + + // address = opsizeof brackopen exp brackclose + @Override + public void caseAAddress(AAddress node) + { + inAAddress(node); + node.getOpsizeof().apply(this); + NasmSize sizeof = size; + node.getExp().apply(this); + NasmExp val = exp; + operand = new NasmAddress(val, sizeof); + outAAddress(node); + } + + + // opsizeof = {byte} byte + @Override + public void caseAByteOpsizeof(AByteOpsizeof node) + { + inAByteOpsizeof(node); + size = NasmSize.BYTE; + outAByteOpsizeof(node); + } + + // opsizeof = {word} word + @Override + public void caseAWordOpsizeof(AWordOpsizeof node) + { + inAWordOpsizeof(node); + size = NasmSize.WORD; + outAWordOpsizeof(node); + } + + // opsizeof = {dword} dword + @Override + public void caseADwordOpsizeof(ADwordOpsizeof node) + { + inADwordOpsizeof(node); + size = NasmSize.DWORD; + outADwordOpsizeof(node); + } + + // opsizeof = {empty} + @Override + public void caseAEmptyOpsizeof(AEmptyOpsizeof node) + { + inAEmptyOpsizeof(node); + size = NasmSize.UNDEFINED; + outAEmptyOpsizeof(node); + } + + // exp = {plus} exp plus exp1 + @Override + public void caseAPlusExp(APlusExp node) + { + inAPlusExp(node); + node.getExp().apply(this); + NasmExp op1 = exp; + node.getExp1().apply(this); + NasmExp op2 = exp; + exp = new NasmExpPlus(op1, op2); + outAPlusExp(node); + } + + // exp = {minus} exp minus exp1 + @Override + public void caseAMinusExp(AMinusExp node) + { + inAMinusExp(node); + node.getExp().apply(this); + NasmExp op1 = exp; + node.getExp1().apply(this); + NasmExp op2 = exp; + exp = new NasmExpMinus(op1, op2); + outAMinusExp(node); + } + + // exp = {next} exp1 + @Override + public void caseANextExp(ANextExp node) + { + inANextExp(node); + if(node.getExp1() != null) + { + node.getExp1().apply(this); + } + outANextExp(node); + } + + + // exp1 = {times} exp1 times exp2 + @Override + public void caseATimesExp1(ATimesExp1 node) + { + inATimesExp1(node); + node.getExp1().apply(this); + NasmExp op1 = exp; + node.getExp2().apply(this); + NasmExp op2 = exp; + exp = new NasmExpTimes(op1, op2); + outATimesExp1(node); + } + + // exp1 = {next} exp2 + @Override + public void caseANextExp1(ANextExp1 node) + { + inANextExp1(node); + if(node.getExp2() != null) + { + node.getExp2().apply(this); + } + outANextExp1(node); + } + + + // exp2 = {label} label + @Override + public void caseALabelExp2(ALabelExp2 node) + { + inALabelExp2(node); + node.getLabel().apply(this); + exp = label; + outALabelExp2(node); + } + + // exp2 = {numconst} numconst + @Override + public void caseANumconstExp2(ANumconstExp2 node) + { + inANumconstExp2(node); + node.getNumconst().apply(this); + exp = (NasmConstant)operand; + outANumconstExp2(node); + } + + // exp2 = {register} register + @Override + public void caseARegisterExp2(ARegisterExp2 node) + { + inARegisterExp2(node); + node.getRegister().apply(this); + exp = (NasmRegister) operand; + outARegisterExp2(node); + } + + // numconst = number + @Override + public void caseANumconst(ANumconst node) + { + inANumconst(node); + operand = new NasmConstant(Integer.parseInt(node.getNumber().getText())); + outANumconst(node); + } + + // register = {temp} prefix_register number + @Override + public void caseATempRegister(ATempRegister node) + { + inATempRegister(node); + int regNb = Integer.parseInt(node.getNumber().getText()); + if (regNb > nasm.getTempCounter()) + nasm.setTempCounter(regNb); + operand = new NasmRegister(regNb); + outATempRegister(node); + } + + // register = {eax} eax + @Override + public void caseAEaxRegister(AEaxRegister node) + { + inAEaxRegister(node); + NasmRegister reg = new NasmRegister(0); + reg.colorRegister(Nasm.REG_EAX); + operand = reg; + outAEaxRegister(node); + } + + // register = {ebx} ebx + @Override + public void caseAEbxRegister(AEbxRegister node) + { + inAEbxRegister(node); + NasmRegister reg = new NasmRegister(0); + reg.colorRegister(Nasm.REG_EBX); + operand = reg; + outAEbxRegister(node); + } + + // register = {ecx} ecx + @Override + public void caseAEcxRegister(AEcxRegister node) + { + inAEcxRegister(node); + NasmRegister reg = new NasmRegister(0); + reg.colorRegister(Nasm.REG_ECX); + operand = reg; + outAEcxRegister(node); + } + + // register = {edx} edx + @Override + public void caseAEdxRegister(AEdxRegister node) + { + inAEdxRegister(node); + NasmRegister reg = new NasmRegister(0); + reg.colorRegister(Nasm.REG_EDX); + operand = reg; + outAEdxRegister(node); + } + + // register = {ebp} ebp + @Override + public void caseAEbpRegister(AEbpRegister node) + { + inAEbpRegister(node); + NasmRegister reg = new NasmRegister(0); + reg.colorRegister(Nasm.REG_EBP); + operand = reg; + outAEbpRegister(node); + } + + // register = {esp} esp + @Override + public void caseAEspRegister(AEspRegister node) + { + inAEspRegister(node); + NasmRegister reg = new NasmRegister(0); + reg.colorRegister(Nasm.REG_ESP); + operand = reg; + outAEspRegister(node); + } + + + // oplabel = {label} label semicol + @Override + public void caseALabelOplabel(ALabelOplabel node) + { + inALabelOplabel(node); + node.getLabel().apply(this); + outALabelOplabel(node); + } + + // oplabel = {empty} + @Override + public void caseAEmptyOplabel(AEmptyOplabel node) + { + inAEmptyOplabel(node); + label = null; + outAEmptyOplabel(node); + } + + // label = id + @Override + public void caseALabel(ALabel node) + { + inALabel(node); + label = new NasmLabel(node.getId().getText()); + outALabel(node); + } +} + + + diff --git a/src/nasm/Nasm.java b/src/nasm/Nasm.java new file mode 100644 index 0000000000000000000000000000000000000000..3bd34e4dffb1a3c4d05b5b030653882f6aee44da --- /dev/null +++ b/src/nasm/Nasm.java @@ -0,0 +1,172 @@ +package nasm; +import java.util.*; +import java.io.*; +import ts.*; + +public class Nasm{ + public List<NasmInst> sectionText; + public List<NasmPseudoInst> sectionBss; + protected int tempCounter = 0; + Ts tableGlobale; + public static int REG_EAX = 0; + public static int REG_EBX = 1; + public static int REG_ECX = 2; + public static int REG_EDX = 3; + public static int REG_ESP = 4; + public static int REG_EBP = 5; + public static int REG_UNK = 6; + // public static int NB_PREDEFINED_REG = 7; + + + public Nasm(Ts tableGlobale){ + this.tableGlobale = tableGlobale; + this.sectionBss = new ArrayList<NasmPseudoInst>(); + this.sectionText = new ArrayList<NasmInst>(); + populateSectionBss(tableGlobale); + } + + public Nasm(){ + this.sectionBss = new ArrayList<NasmPseudoInst>(); + this.sectionText = new ArrayList<NasmInst>(); + } + + public int getTempCounter(){return this.tempCounter;} + public int setTempCounter(int c){return this.tempCounter = c;} + + public void ajoutePseudoInst(NasmPseudoInst pseudoInst){ + this.sectionBss.add(pseudoInst); + } + + public void ajouteInst(NasmInst inst){ + if(inst instanceof NasmMov && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){ + NasmRegister newReg = newRegister(); + this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); + this.sectionText.add(new NasmMov(null, inst.destination, newReg, "on passe par un registre temporaire")); + return; + } + if(inst instanceof NasmAdd && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){ + NasmRegister newReg = newRegister(); + this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); + this.sectionText.add(new NasmAdd(null, inst.destination, newReg, "on passe par un registre temporaire")); + return; + } + if(inst instanceof NasmSub && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){ + NasmRegister newReg = newRegister(); + this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); + this.sectionText.add(new NasmSub(null, inst.destination, newReg, "on passe par un registre temporaire")); + return; + } + if(inst instanceof NasmMul && inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress){ + NasmRegister newReg = newRegister(); + this.sectionText.add(new NasmMov(inst.label, newReg, inst.source, inst.comment)); + this.sectionText.add(new NasmMul(null, inst.destination, newReg, "on passe par un registre temporaire")); + return; + } + + + // if(inst instanceof NasmCmp && inst.destination instanceof NasmConstant && inst.source instanceof NasmConstant){ + if(inst instanceof NasmCmp + && (inst.destination instanceof NasmConstant + || (inst.destination instanceof NasmAddress && inst.source instanceof NasmAddress))){ + NasmRegister newReg = newRegister(); + this.sectionText.add(new NasmMov(inst.label, newReg, inst.destination, inst.comment)); + this.sectionText.add(new NasmCmp(null, newReg, inst.source, "on passe par un registre temporaire")); + return; + } + + this.sectionText.add(inst); + } + + public NasmRegister newRegister(){ + return new NasmRegister(tempCounter++); + } + + public void populateSectionBss(Ts tableGlobale){ + ajoutePseudoInst(new NasmResb(new NasmLabel("sinput"), 255, "reserve a 255 byte space in memory for the users input string")); + Set< Map.Entry< String, TsItemVar> > st = tableGlobale.variables.entrySet(); + for (Map.Entry< String, TsItemVar> me:st){ + TsItemVar tsItem = me.getValue(); + String identif = me.getKey(); + if(tsItem instanceof TsItemVarSimple) + ajoutePseudoInst(new NasmResd(new NasmLabel(identif), tsItem.type.taille(), "variable globale")); + if(tsItem instanceof TsItemVarTab) + ajoutePseudoInst(new NasmResd(new NasmLabel(identif), tsItem.type.taille() * ((TsItemVarTab)tsItem).taille, "variable globale")); + // ajoutePseudoInst(new NasmResd(new NasmLabel(identif), tsItem.taille*4, "variable globale")); + } + } + + + public void affichePreNasm(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".pre-nasm"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + affiche(out); + } + + public void afficheNasm(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".nasm"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + affiche(out); + } + + public void affiche(PrintStream out){ + out.println("%include\t'io.asm'\n"); + out.println("section\t.bss"); + Iterator<NasmPseudoInst> iter = this.sectionBss.iterator(); + while(iter.hasNext()){ + out.println(iter.next()); + } + + out.println("\nsection\t.text"); + out.println("global _start"); + out.println("_start:"); + Iterator<NasmInst> iter2 = this.sectionText.iterator(); + while(iter2.hasNext()){ + out.println(iter2.next()); + } + } +} +/* + public void affichePreambule(PrintStream out) + { + out.println("%include\t'io.asm'\n"); + out.println("section\t.bss"); + out.println("sinput:\tresb\t255\t;reserve a 255 byte space in memory for the users input string"); + + + Set< Map.Entry< String, TsItemVar> > st = tableGlobale.variables.entrySet(); + for (Map.Entry< String, TsItemVar> me:st){ + TsItemVar tsItem = me.getValue(); + String identif = me.getKey(); + out.println(identif + " :\tresd\t" + tsItem.taille * 4); + } + out.println("\nsection\t.text"); + out.println("global _start"); + out.println("_start:"); + } + + + */ diff --git a/src/nasm/NasmAdd.java b/src/nasm/NasmAdd.java new file mode 100644 index 0000000000000000000000000000000000000000..340d0df41e5daa194a3f5124db85821edb4ac527 --- /dev/null +++ b/src/nasm/NasmAdd.java @@ -0,0 +1,25 @@ +package nasm; + +public class NasmAdd extends NasmInst { + + public NasmAdd(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + + destUse = true; + destDef = true; + srcUse = true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "add", this.destination, this.source, this.comment); + } + + +} diff --git a/src/nasm/NasmAddress.java b/src/nasm/NasmAddress.java new file mode 100644 index 0000000000000000000000000000000000000000..f81e92aa623aae32aafa2b73d3d27660d3831913 --- /dev/null +++ b/src/nasm/NasmAddress.java @@ -0,0 +1,26 @@ +package nasm; + +public class NasmAddress extends NasmOperand { + + public NasmExp val; + public NasmSize size; + + public NasmAddress(NasmExp val, NasmSize size){ + this.val = val; + this.size = size; + } + + public String toString(){ + return this.size.toString() + " [" + this.val.toString() + "]"; + } + + public boolean isGeneralRegister(){ + return false; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + +} diff --git a/src/nasm/NasmAnd.java b/src/nasm/NasmAnd.java new file mode 100644 index 0000000000000000000000000000000000000000..c4c32e30c104c706c7509f928ad6a9a24f586ad1 --- /dev/null +++ b/src/nasm/NasmAnd.java @@ -0,0 +1,24 @@ +package nasm; + +public class NasmAnd extends NasmInst { + + public NasmAnd(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + destUse = true; + destDef = true; + srcUse = true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "and", this.destination, this.source, this.comment); + } + + +} diff --git a/src/nasm/NasmCall.java b/src/nasm/NasmCall.java new file mode 100644 index 0000000000000000000000000000000000000000..d7a43e1e4cd8be9486944df4e20fa11a6dab5ed7 --- /dev/null +++ b/src/nasm/NasmCall.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmCall extends NasmInst { + + public NasmCall(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "call", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmCmp.java b/src/nasm/NasmCmp.java new file mode 100644 index 0000000000000000000000000000000000000000..6926d8f142289e1d1dfb869d968dfa945db15abe --- /dev/null +++ b/src/nasm/NasmCmp.java @@ -0,0 +1,23 @@ +package nasm; + +public class NasmCmp extends NasmInst { + + public NasmCmp(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + destUse = true; + srcUse= true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "cmp", this.destination, this.source, this.comment); + } + + +} diff --git a/src/nasm/NasmConstant.java b/src/nasm/NasmConstant.java new file mode 100644 index 0000000000000000000000000000000000000000..9f6a74991e9ae7c1ad6a9ec17c9c90225500aec6 --- /dev/null +++ b/src/nasm/NasmConstant.java @@ -0,0 +1,28 @@ +package nasm; +import java.util.ArrayList; + +public class NasmConstant extends NasmOperand implements NasmExp{ + public int val; + public NasmConstant(int val){ + this.val = val; + } + + public String toString(){ + return Integer.toString(this.val); + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public ArrayList<NasmRegister> getRegisters() + { + ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>(); + this.getRegisters(registerList); + return registerList; + } + public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList) + { + return registerList; + } +} diff --git a/src/nasm/NasmDiv.java b/src/nasm/NasmDiv.java new file mode 100644 index 0000000000000000000000000000000000000000..c3cc45f789610566e0dba0e60c68716a24d0c510 --- /dev/null +++ b/src/nasm/NasmDiv.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmDiv extends NasmInst { + + public NasmDiv(NasmOperand label, NasmOperand source, String comment){ + srcUse = true; + this.label = label; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "idiv", this.source, null, this.comment); + } +} diff --git a/src/nasm/NasmEmpty.java b/src/nasm/NasmEmpty.java new file mode 100644 index 0000000000000000000000000000000000000000..808f6903d9a5735a2a15625226377d0c0fa7f996 --- /dev/null +++ b/src/nasm/NasmEmpty.java @@ -0,0 +1,18 @@ +package nasm; + +public class NasmEmpty extends NasmInst { + + public NasmEmpty(NasmOperand label, String comment){ + this.label = label; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "", null, null, this.comment); + } + +} diff --git a/src/nasm/NasmEval.java b/src/nasm/NasmEval.java new file mode 100644 index 0000000000000000000000000000000000000000..3178a3cc6673368d23b6d5b3b23dd2e7c003b9b9 --- /dev/null +++ b/src/nasm/NasmEval.java @@ -0,0 +1,410 @@ +package nasm; +import java.io.FileNotFoundException; +import java.io.PrintStream; +import java.util.ArrayList; +import java.util.HashMap; +import util.Memory; + +/* +This class emulates pre-nasm and nasm code for x86-64 architecture. +It handles only integers on 4 bytes and have unlimited register. + */ + +public class NasmEval implements NasmVisitor<Integer>{ + private Nasm code; + private int dataSize = 0; + + private int regNb; + private HashMap<String, Integer> labelToAddress; + private Memory memory; + private boolean stop; + private ArrayList<Integer> output; + + // registers + private int[] registers; + + private int ebp; + private int eip = 0; + private int eax = 0; + private int ebx = 0; + private int ecx = 0; + private int edx = 0; + + //flags + // Carry Flag -> not used + private boolean CF = false; + // Parity Flag -> not used + private boolean PF = false; + // Zero Flag + private boolean ZF = false; + // Sign Flag + private boolean SF = false; + // Overflow Flag -> not used + private boolean OF = false; + + private int verboseLevel; + + public NasmEval(Nasm code, int stackSize, int verboseLevel){ + this.code = code; + this.verboseLevel = verboseLevel; + regNb = this.code.getTempCounter(); + registers = new int[regNb+1]; + eip = 0; + stop = false; + + output = new ArrayList<>(); + labelToAddress = new HashMap<>(); + + associateLabelToAddress(); + memory = new Memory(dataSize, stackSize); + + while(!stop && eip < code.sectionText.size()){ + NasmInst inst = this.code.sectionText.get(eip); + if(verboseLevel > 0){ + System.out.println("--------------------------------------"); + + PrintGlobalVariables(); + // System.out.println("eip = " + eip + "\tesp = " + memory.getTopInt() + "\t ebp = " + ebp); + System.out.println("eip = " + eip + "\tesp = " + memory.esp + "\t ebp = " + ebp); + System.out.println("eax = " + eax + "\tebx = " + ebx + "\tecx = " + ecx + "\tedx = " + edx); + System.out.println("CF = " + CF + "\tPF = " + PF + "\tZF = " + ZF + "\tSF = " + SF + "\tOF = " + OF); + printRegisters(); + System.out.print("PILE : \t"); + memory.printStack(); + System.out.println(inst); + } + eip = inst.accept(this); + } + // displayOutput(); + } + + public void PrintGlobalVariables(){ + for (HashMap.Entry<String, Integer> e : labelToAddress.entrySet()) + + // System.out.println("[" + e.getValue() + "]\t" + e.getKey() + " = " + memory.readInt(e.getValue())); + System.out.println(e.getKey() + " = " + memory.readInt(e.getValue()) + " adr: " + e.getValue()); + + } + + public void printRegisters(){ + for(int i=0; i < regNb; i++){ + System.out.print("r" + i + ":" + registers[i] + "\t"); + } + // System.out.println(); + } + + public void displayOutput(){ + for(var val : output) + System.out.println(val); + } + + public void displayOutput(String outputFile) throws FileNotFoundException { + var out = new PrintStream(outputFile); + for(var val : output) + out.println(val); + } + + private void associateLabelToAddress(){ + var instructions = code.sectionText; + // associate labels to line numbers + for(int lineNb = 0; lineNb <instructions.size(); lineNb++){ + if(instructions.get(lineNb).label != null) { + var label = (NasmLabel)instructions.get(lineNb).label; + labelToAddress.put(label.val, lineNb); + } + } + // compute addresses of global variables and associate them to labels + for(int i = 0; i < code.sectionBss.size(); i++){ + NasmPseudoInst pseudoInst = this.code.sectionBss.get(i); + labelToAddress.put(pseudoInst.label.val, dataSize); + // System.out.println("var :" + pseudoInst.label.val + " address = " + dataSize); + dataSize += pseudoInst.nb * pseudoInst.sizeInBytes; + } + } + + /*------------------------------------------*/ + private void copy(NasmOperand dest, int value){ + if(dest instanceof NasmAddress) + copy((NasmAddress) dest, value); + else if(dest instanceof NasmRegister) + copy((NasmRegister) dest, value); + } + + private void copy(NasmAddress dest, int value){ + int address = dest.val.accept(this); + memory.writeInt(address, value); + } + + + private void copy(NasmRegister dest, int value){ + writeToRegister(dest, value); + } + + /*------------------------------------------*/ + + // return value stored in regiter + private int readFromRegister(NasmRegister reg){ + if(reg.color == Nasm.REG_EAX) + return eax; + if (reg.color == Nasm.REG_EBX) + return ebx; + if (reg.color == Nasm.REG_ECX) + return ecx; + if (reg.color == Nasm.REG_EDX) + return edx; + if (reg.color == Nasm.REG_ESP) + return memory.esp; + if (reg.color == Nasm.REG_EBP) + return ebp; + else + return registers[reg.val]; + + } + // write in a register + + private void writeToRegister(NasmRegister reg, int value){ + if(reg.color == Nasm.REG_EAX) + eax = value; + else if (reg.color == Nasm.REG_EBX) + ebx = value; + else if (reg.color == Nasm.REG_ECX) + ecx = value; + else if (reg.color == Nasm.REG_EDX) + edx = value; + else if (reg.color == Nasm.REG_ESP) + memory.esp = value; + else if (reg.color == Nasm.REG_EBP) + ebp = value; + else + registers[reg.val] = value; + } + + /* visit address -> return the value stored at this address */ + @Override + public Integer visit(NasmAddress adr) { + return memory.readInt(adr.val.accept(this)); + } + + /* visit register -> return the value stored in the register */ + @Override + public Integer visit(NasmRegister operand) { + if(operand.color == Nasm.REG_EAX) + return eax; + if (operand.color == Nasm.REG_EBX) + return ebx; + if (operand.color == Nasm.REG_ECX) + return ecx; + if (operand.color == Nasm.REG_EDX) + return edx; + if (operand.color == Nasm.REG_ESP) + return memory.esp; + if (operand.color == Nasm.REG_EBP) + return ebp; + else + return registers[operand.val]; + } + + /* visit constant -> return value of the constant */ + @Override + public Integer visit(NasmConstant operand) { + return operand.val; + } + + /* visit label -> return address corresponding to the label */ + @Override + public Integer visit(NasmLabel operand) { + if(labelToAddress.containsKey(operand.val)) + return labelToAddress.get(operand.val); + else + throw new RuntimeException("label " + operand.val + "does not correspond to address"); + } + + + /* visiting an instruction returns new value of eip */ + /* arithmetic operations */ + + @Override + public Integer visit(NasmAdd inst) { + copy(inst.destination, inst.source.accept(this) + inst.destination.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmSub inst) { + copy(inst.destination, inst.destination.accept(this) - inst.source.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmMul inst) { + copy(inst.destination, inst.source.accept(this) * inst.destination.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmDiv inst) { + var divisor = inst.source.accept(this); + var temp = eax; + eax = temp / divisor; + edx = temp % divisor; + return eip + 1; + } + + /* logical operations */ + @Override + public Integer visit(NasmOr inst) { + copy(inst.destination, inst.source.accept(this) | inst.destination.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmNot inst) { + copy(inst.destination, ~ inst.destination.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmXor inst) { + copy(inst.destination, inst.source.accept(this) ^ inst.destination.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmAnd inst) { + copy(inst.destination, inst.source.accept(this) & inst.destination.accept(this)); + return eip + 1; + } + + /* function call */ + @Override + public Integer visit(NasmCall inst) { + if(inst.address instanceof NasmLabel && ((NasmLabel)inst.address).val.equals("iprintLF")){ + output.add(eax); + return eip + 1; + } + memory.pushInt(eip); + return inst.address.accept(this); + } + + /* comparison */ + @Override + public Integer visit(NasmCmp inst) { + int valSrc = inst.source.accept(this); + int valDest = inst.destination.accept(this); + ZF = (valDest == valSrc)? true : false; + SF = (valDest < valSrc)? true : false; + return eip + 1; + } + + /* jumps */ + @Override + public Integer visit(NasmJe inst) { + return (ZF)? inst.address.accept(this) : eip + 1; + } + + @Override + public Integer visit(NasmJle inst) { + return (ZF || SF)? inst.address.accept(this) : eip + 1; + } + + @Override + public Integer visit(NasmJne inst) { + return (!ZF)? inst.address.accept(this) : eip + 1; + } + + @Override + public Integer visit(NasmJge inst) { + return (ZF || !SF)? inst.address.accept(this) : eip + 1; + } + + @Override + public Integer visit(NasmJl inst) { + return (!ZF && SF)? inst.address.accept(this) : eip + 1; + } + + @Override + public Integer visit(NasmJg inst) { + return (!ZF || SF)? inst.address.accept(this) : eip + 1; + } + + @Override + public Integer visit(NasmJmp inst) { + return inst.address.accept(this); + } + + @Override + public Integer visit(NasmPop inst) { + copy(inst.destination, memory.popInt()); + return eip + 1; + } + + @Override + public Integer visit(NasmPush inst) { + memory.pushInt(inst.source.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmRet inst) { + return memory.popInt() + 1; + } + + @Override + public Integer visit(NasmMov inst) { + copy(inst.destination, inst.source.accept(this)); + return eip + 1; + } + + @Override + public Integer visit(NasmInt inst) { + if(eax == 1) + stop = true; + return eip + 1; + } + + @Override + public Integer visit(NasmInst inst) { + return 0; + } + + @Override + public Integer visit(NasmEmpty inst) { + return eip + 1; + } + + public Integer visit(NasmResb pseudoInst){return 0;} + public Integer visit(NasmResw pseudoInst){return 0;} + public Integer visit(NasmResd pseudoInst){return 0;} + public Integer visit(NasmResq pseudoInst){return 0;} + public Integer visit(NasmRest pseudoInst){return 0;} + + /* visit expression -> returns an address */ + + public Integer visit(NasmExp exp) { /* c'est moche, il faudrait modifier ça !! */ + if(exp instanceof NasmLabel) + return ((NasmLabel)exp).accept(this); + + if(exp instanceof NasmRegister) + return ((NasmRegister)exp).accept(this); + + if(exp instanceof NasmLabel) + return ((NasmLabel)exp).accept(this); + + if(exp instanceof NasmConstant) + return ((NasmConstant)exp).accept(this); + + if(exp instanceof NasmExpPlus) + return ((NasmExpPlus)exp).accept(this); + + if(exp instanceof NasmExpMinus) + return ((NasmExpMinus)exp).accept(this); + + // if(exp instanceof NasmExpTimes) + return ((NasmExpTimes)exp).accept(this); + } + public Integer visit(NasmExpPlus exp) {return exp.op1.accept(this) + exp.op2.accept(this);} + public Integer visit(NasmExpMinus exp){return exp.op1.accept(this) - exp.op2.accept(this);} + public Integer visit(NasmExpTimes exp){return exp.op1.accept(this) * exp.op2.accept(this);} + + +} diff --git a/src/nasm/NasmExp.java b/src/nasm/NasmExp.java new file mode 100644 index 0000000000000000000000000000000000000000..6e51c1d1d92095a3dcdbd99ea4cb2831e32857bc --- /dev/null +++ b/src/nasm/NasmExp.java @@ -0,0 +1,11 @@ +package nasm; +import java.util.ArrayList; + +public interface NasmExp { + // public boolean isStackAddress(); + public ArrayList<NasmRegister> getRegisters(); + public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList); + + + public <T> T accept(NasmVisitor <T> visitor); +} diff --git a/src/nasm/NasmExpMinus.java b/src/nasm/NasmExpMinus.java new file mode 100644 index 0000000000000000000000000000000000000000..419c1c167e89e2cf0d1ed5a4236b8e9c160d0020 --- /dev/null +++ b/src/nasm/NasmExpMinus.java @@ -0,0 +1,34 @@ +package nasm; +import java.util.ArrayList; + +public class NasmExpMinus implements NasmExp{ + public NasmExp op1; + public NasmExp op2; + + public NasmExpMinus(NasmExp op1, NasmExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + @Override + public String toString() { + return op1.toString() + "-" + op2.toString(); + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public ArrayList<NasmRegister> getRegisters() + { + ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>(); + this.getRegisters(registerList); + return registerList; + } + public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList) + { + this.op1.getRegisters(registerList); + this.op2.getRegisters(registerList); + return registerList; + } +} diff --git a/src/nasm/NasmExpPlus.java b/src/nasm/NasmExpPlus.java new file mode 100644 index 0000000000000000000000000000000000000000..440d310d3fa1b3e8b46c6f9b06d01252eb9d7587 --- /dev/null +++ b/src/nasm/NasmExpPlus.java @@ -0,0 +1,34 @@ +package nasm; +import java.util.ArrayList; + +public class NasmExpPlus implements NasmExp{ + public NasmExp op1; + public NasmExp op2; + + public NasmExpPlus(NasmExp op1, NasmExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + @Override + public String toString() { + return op1.toString() + "+" + op2.toString(); + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public ArrayList<NasmRegister> getRegisters() + { + ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>(); + this.getRegisters(registerList); + return registerList; + } + public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList) + { + this.op1.getRegisters(registerList); + this.op2.getRegisters(registerList); + return registerList; + } +} diff --git a/src/nasm/NasmExpTimes.java b/src/nasm/NasmExpTimes.java new file mode 100644 index 0000000000000000000000000000000000000000..efc07f3a498d2a90997e3f572916b83daa864394 --- /dev/null +++ b/src/nasm/NasmExpTimes.java @@ -0,0 +1,34 @@ +package nasm; +import java.util.ArrayList; + +public class NasmExpTimes implements NasmExp{ + public NasmExp op1; + public NasmExp op2; + + public NasmExpTimes(NasmExp op1, NasmExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + @Override + public String toString() { + return op1.toString() + "+" + op2.toString(); + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public ArrayList<NasmRegister> getRegisters() + { + ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>(); + this.getRegisters(registerList); + return registerList; + } + public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList) + { + this.op1.getRegisters(registerList); + this.op2.getRegisters(registerList); + return registerList; + } +} diff --git a/src/nasm/NasmInst.java b/src/nasm/NasmInst.java new file mode 100644 index 0000000000000000000000000000000000000000..5d81f8f999d766a2d0cf7bf6c766415b14e274a7 --- /dev/null +++ b/src/nasm/NasmInst.java @@ -0,0 +1,36 @@ +package nasm; + +public abstract class NasmInst{ + public NasmOperand label = null; + public NasmOperand destination = null; + public NasmOperand source = null; + public NasmOperand address = null; + public boolean destUse = false; + public boolean destDef = false; + public boolean srcUse = false; + public boolean srcDef = false; + String comment; + + void addLabel(String formatInst, NasmOperand label){ + formatInst += label; + } + + public String formatInst(NasmOperand label, String opcode, NasmOperand arg1, NasmOperand arg2, String comment){ + String s = ""; + if(label != null) + s = s + label + " :"; + s = s + "\t" + opcode; + if(arg1 != null) + s = s + "\t" + arg1; + if(arg2 != null) + s = s + ",\t" + arg2; + if(comment != null & comment != "") + s = s + "\t;" + comment; + return s; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + +} diff --git a/src/nasm/NasmInt.java b/src/nasm/NasmInt.java new file mode 100644 index 0000000000000000000000000000000000000000..3e6a5b5114a89be83f45efa6db827197e706f18d --- /dev/null +++ b/src/nasm/NasmInt.java @@ -0,0 +1,18 @@ +package nasm; + +public class NasmInt extends NasmInst { + + public NasmInt(NasmOperand label, String comment){ + this.label = label; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "int 0x80", null, null, this.comment); + } + +} diff --git a/src/nasm/NasmJe.java b/src/nasm/NasmJe.java new file mode 100644 index 0000000000000000000000000000000000000000..e40ab6c72b69d222c43dc8157d301ef43287b585 --- /dev/null +++ b/src/nasm/NasmJe.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmJe extends NasmInst { + + public NasmJe(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "je", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmJg.java b/src/nasm/NasmJg.java new file mode 100644 index 0000000000000000000000000000000000000000..1f6881c91c9fe8d4a4d0df7b604dc197ab655edc --- /dev/null +++ b/src/nasm/NasmJg.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmJg extends NasmInst { + + public NasmJg(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "jg", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmJge.java b/src/nasm/NasmJge.java new file mode 100644 index 0000000000000000000000000000000000000000..d5091cb3a26e3588606edc8916352c825726b767 --- /dev/null +++ b/src/nasm/NasmJge.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmJge extends NasmInst { + + public NasmJge(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "jge", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmJl.java b/src/nasm/NasmJl.java new file mode 100644 index 0000000000000000000000000000000000000000..5216ba3364e6e7d10cda6a0dcb3b1cbe70158944 --- /dev/null +++ b/src/nasm/NasmJl.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmJl extends NasmInst { + + public NasmJl(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "jl", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmJle.java b/src/nasm/NasmJle.java new file mode 100644 index 0000000000000000000000000000000000000000..ac84e86eb8b5d827a7d25f457a63d7c9681390c6 --- /dev/null +++ b/src/nasm/NasmJle.java @@ -0,0 +1,25 @@ +package nasm; + +public class NasmJle extends NasmInst { + + public NasmJle(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + // String formatInst + // addLabel(label); + + //return formatInst; + + + return super.formatInst(this.label, "jle", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmJmp.java b/src/nasm/NasmJmp.java new file mode 100644 index 0000000000000000000000000000000000000000..62377f126ac55d1ec5600bbcea12cd8b4679be72 --- /dev/null +++ b/src/nasm/NasmJmp.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmJmp extends NasmInst { + + public NasmJmp(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "jmp", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmJne.java b/src/nasm/NasmJne.java new file mode 100644 index 0000000000000000000000000000000000000000..06531c879260b981043a8a8b9064c422637da305 --- /dev/null +++ b/src/nasm/NasmJne.java @@ -0,0 +1,19 @@ +package nasm; + +public class NasmJne extends NasmInst { + + public NasmJne(NasmOperand label, NasmOperand address, String comment){ + this.label = label; + this.address = address; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "jne", this.address, null, this.comment); + } + +} diff --git a/src/nasm/NasmLabel.java b/src/nasm/NasmLabel.java new file mode 100644 index 0000000000000000000000000000000000000000..85d49095fa53b78c098461e1fdd3c26810172051 --- /dev/null +++ b/src/nasm/NasmLabel.java @@ -0,0 +1,28 @@ +package nasm; +import java.util.ArrayList; + +public class NasmLabel extends NasmOperand implements NasmExp { + public String val; + + public NasmLabel(String val){ + this.val = val; + } + public String toString(){ + return this.val; + } + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + public boolean isStackAddress(){return false;} + + public ArrayList<NasmRegister> getRegisters() + { + ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>(); + this.getRegisters(registerList); + return registerList; + } + public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList) + { + return registerList; + } +} diff --git a/src/nasm/NasmMov.java b/src/nasm/NasmMov.java new file mode 100644 index 0000000000000000000000000000000000000000..8d3d7435b32a56289f9402aa7196f1b7a10aef33 --- /dev/null +++ b/src/nasm/NasmMov.java @@ -0,0 +1,22 @@ +package nasm; + +public class NasmMov extends NasmInst { + + public NasmMov(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + destDef = true; + srcUse = true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "mov", this.destination, this.source, this.comment); + } + +} diff --git a/src/nasm/NasmMul.java b/src/nasm/NasmMul.java new file mode 100644 index 0000000000000000000000000000000000000000..3be1297c361a844e3f1f1ad95b43f94eb4474a03 --- /dev/null +++ b/src/nasm/NasmMul.java @@ -0,0 +1,26 @@ +package nasm; + +public class NasmMul extends NasmInst { + public NasmMul(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + destUse = true; + destDef = true; + srcUse = true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + /* public String toString(){ + return super.formatInst(this.label, "imul", this.source, null, this.comment); + }*/ + + public String toString(){ + return super.formatInst(this.label, "imul", this.destination, this.source, this.comment); + } + +} diff --git a/src/nasm/NasmNot.java b/src/nasm/NasmNot.java new file mode 100644 index 0000000000000000000000000000000000000000..c43ddf2cb91445518475e843c70bc0e5ee064da6 --- /dev/null +++ b/src/nasm/NasmNot.java @@ -0,0 +1,21 @@ +package nasm; + +public class NasmNot extends NasmInst { + + public NasmNot(NasmOperand label, NasmOperand destination, String comment){ + destUse = true; + destDef = true; + this.label = label; + this.destination = destination; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "not", this.destination, null, this.comment); + } + +} diff --git a/src/nasm/NasmOperand.java b/src/nasm/NasmOperand.java new file mode 100644 index 0000000000000000000000000000000000000000..5fb05ba7c9194420c32219b93cdc0bb8fd1b1ea4 --- /dev/null +++ b/src/nasm/NasmOperand.java @@ -0,0 +1,8 @@ +package nasm; + +public abstract class NasmOperand { + public boolean isGeneralRegister(){ + return false; + } + public abstract <T> T accept(NasmVisitor <T> visitor); +} diff --git a/src/nasm/NasmOr.java b/src/nasm/NasmOr.java new file mode 100644 index 0000000000000000000000000000000000000000..3dd09f3e87601aa305a97b9fbaf4c44741bcfad7 --- /dev/null +++ b/src/nasm/NasmOr.java @@ -0,0 +1,24 @@ +package nasm; + +public class NasmOr extends NasmInst { + + public NasmOr(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + destUse = true; + destDef = true; + srcUse = true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "or", this.destination, this.source, this.comment); + } + + +} diff --git a/src/nasm/NasmPop.java b/src/nasm/NasmPop.java new file mode 100644 index 0000000000000000000000000000000000000000..88c46bfbfbd9158a652369c6598b86f18abc993f --- /dev/null +++ b/src/nasm/NasmPop.java @@ -0,0 +1,20 @@ +package nasm; + +public class NasmPop extends NasmInst { + + public NasmPop(NasmOperand label, NasmOperand destination, String comment){ + destDef = true; + this.label = label; + this.destination = destination; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "pop", this.destination, null, this.comment); + } + +} diff --git a/src/nasm/NasmPseudoInst.java b/src/nasm/NasmPseudoInst.java new file mode 100644 index 0000000000000000000000000000000000000000..27e14c7935b4d3e1b49f848456552a1d0fbc1f92 --- /dev/null +++ b/src/nasm/NasmPseudoInst.java @@ -0,0 +1,28 @@ +package nasm; + +public abstract class NasmPseudoInst{ + public NasmLabel label = null; + public int nb = 1; + public int sizeInBytes; + String comment; + + void addLabel(String formatInst, NasmOperand label){ + formatInst += label; + } + + public String formatInst(NasmOperand label, String opcode, int nb, String comment){ + String s = ""; + if(label != null) + s = s + label + " :"; + s = s + "\t" + opcode; + s = s + "\t" + nb; + if(comment != null) + s = s + "\t;" + comment; + return s; + } + + /* public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + }*/ + +} diff --git a/src/nasm/NasmPush.java b/src/nasm/NasmPush.java new file mode 100644 index 0000000000000000000000000000000000000000..a663634e1517adf6acecac57d8de09365c059836 --- /dev/null +++ b/src/nasm/NasmPush.java @@ -0,0 +1,20 @@ +package nasm; + +public class NasmPush extends NasmInst { + + public NasmPush(NasmOperand label, NasmOperand source, String comment){ + // srcUse = true; + this.label = label; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "push", this.source, null, this.comment); + } + +} diff --git a/src/nasm/NasmRegister.java b/src/nasm/NasmRegister.java new file mode 100644 index 0000000000000000000000000000000000000000..9f00453fd70bb73d04c267f2f8008a4af0ca8ea6 --- /dev/null +++ b/src/nasm/NasmRegister.java @@ -0,0 +1,57 @@ +package nasm; +import java.util.ArrayList; + +public class NasmRegister extends NasmOperand implements NasmExp{ + public int val; + public int color = Nasm.REG_UNK; + + public NasmRegister(int val){ + this.val = val; + } + + public void colorRegister(int color){ + this.color = color; + } + + public String toString(){ + if(this.color == Nasm.REG_ESP) return "esp"; + if(this.color == Nasm.REG_EBP) return "ebp"; + if(this.color == Nasm.REG_EAX) return "eax"; + if(this.color == Nasm.REG_EBX) return "ebx"; + if(this.color == Nasm.REG_ECX) return "ecx"; + if(this.color == Nasm.REG_EDX) return "edx"; + else + return "@" + this.val; + } + + public boolean isEbp(){ + if(this.color == Nasm.REG_EBP) return true; + return false; + } + + public boolean isGeneralRegister(){ + if(this.color == Nasm.REG_EAX) return true; + if(this.color == Nasm.REG_EBX) return true; + if(this.color == Nasm.REG_ECX) return true; + if(this.color == Nasm.REG_EDX) return true; + if(this.color == Nasm.REG_UNK) return true; + return false; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public ArrayList<NasmRegister> getRegisters() + { + ArrayList<NasmRegister> registerList = new ArrayList<NasmRegister>(); + this.getRegisters(registerList); + return registerList; + } + public ArrayList<NasmRegister> getRegisters(ArrayList<NasmRegister> registerList) + { + registerList.add(this); + return registerList; + } + +} diff --git a/src/nasm/NasmResb.java b/src/nasm/NasmResb.java new file mode 100644 index 0000000000000000000000000000000000000000..c58418c44532bd7b125b2ed6d6a0c65b3429a659 --- /dev/null +++ b/src/nasm/NasmResb.java @@ -0,0 +1,21 @@ +package nasm; + +public class NasmResb extends NasmPseudoInst { + + public NasmResb(NasmLabel label, int nb, String comment){ + this.label = label; + this.nb = nb; + this.sizeInBytes = 1; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "resb", this.nb, this.comment); + } + + +} diff --git a/src/nasm/NasmResd.java b/src/nasm/NasmResd.java new file mode 100644 index 0000000000000000000000000000000000000000..5b4e73f1c15e6851fb766e7030be484adb99442f --- /dev/null +++ b/src/nasm/NasmResd.java @@ -0,0 +1,21 @@ +package nasm; + +public class NasmResd extends NasmPseudoInst { + + public NasmResd(NasmLabel label, int nb, String comment){ + this.label = label; + this.nb = nb; + this.sizeInBytes = 4; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "resd", this.nb, this.comment); + } + + +} diff --git a/src/nasm/NasmResq.java b/src/nasm/NasmResq.java new file mode 100644 index 0000000000000000000000000000000000000000..671bbfa6ff63c35f695ba01a9324fd627e2a853c --- /dev/null +++ b/src/nasm/NasmResq.java @@ -0,0 +1,21 @@ +package nasm; + +public class NasmResq extends NasmPseudoInst { + + public NasmResq(NasmLabel label, int nb, String comment){ + this.label = label; + this.nb = nb; + this.sizeInBytes = 8; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "resq", this.nb, this.comment); + } + + +} diff --git a/src/nasm/NasmRest.java b/src/nasm/NasmRest.java new file mode 100644 index 0000000000000000000000000000000000000000..6b1c2c05092eb8da6d428878487423b5374f9f46 --- /dev/null +++ b/src/nasm/NasmRest.java @@ -0,0 +1,21 @@ +package nasm; + +public class NasmRest extends NasmPseudoInst { + + public NasmRest(NasmLabel label, int nb, String comment){ + this.label = label; + this.nb = nb; + this.sizeInBytes = 10; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "rest", this.nb, this.comment); + } + + +} diff --git a/src/nasm/NasmResw.java b/src/nasm/NasmResw.java new file mode 100644 index 0000000000000000000000000000000000000000..47bedc935aa2eeaa1a696b93351d6d62136a55ec --- /dev/null +++ b/src/nasm/NasmResw.java @@ -0,0 +1,21 @@ +package nasm; + +public class NasmResw extends NasmPseudoInst { + + public NasmResw(NasmLabel label, int nb, String comment){ + this.label = label; + this.nb = nb; + this.sizeInBytes = 2; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "resw", this.nb, this.comment); + } + + +} diff --git a/src/nasm/NasmRet.java b/src/nasm/NasmRet.java new file mode 100644 index 0000000000000000000000000000000000000000..0c95b985a7f66eb62790dff12f8af1455a87355a --- /dev/null +++ b/src/nasm/NasmRet.java @@ -0,0 +1,18 @@ +package nasm; + +public class NasmRet extends NasmInst { + + public NasmRet(NasmOperand label, String comment){ + this.label = label; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "ret", null, null, this.comment); + } + +} diff --git a/src/nasm/NasmSize.java b/src/nasm/NasmSize.java new file mode 100644 index 0000000000000000000000000000000000000000..3812007288c01ccb8ab2269b668ba9f5f5b80684 --- /dev/null +++ b/src/nasm/NasmSize.java @@ -0,0 +1,20 @@ +package nasm; + +public enum NasmSize { + + BYTE(1, "byte"), + WORD(2, "word"), + DWORD(4, "dword"), + UNDEFINED(0, ""); + private final String name; + private final int value; + + NasmSize(int value, String name) { + this.value = value; + this.name = name; + } + + public String toString(){return name;} + public String getName(){return this.name;} + public int getValue(){return value;} +} \ No newline at end of file diff --git a/src/nasm/NasmSub.java b/src/nasm/NasmSub.java new file mode 100644 index 0000000000000000000000000000000000000000..516271828d69e43a0808e9e4d85410b7126d8fc0 --- /dev/null +++ b/src/nasm/NasmSub.java @@ -0,0 +1,22 @@ +package nasm; + +public class NasmSub extends NasmInst { + + public NasmSub(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + destUse = true; + destDef = true; + srcUse = true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "sub", this.destination, this.source, this.comment); + } +} diff --git a/src/nasm/NasmVisitor.java b/src/nasm/NasmVisitor.java new file mode 100644 index 0000000000000000000000000000000000000000..091f20e9470b925f46df3510421f5bdc643c595a --- /dev/null +++ b/src/nasm/NasmVisitor.java @@ -0,0 +1,47 @@ +package nasm; + +public interface NasmVisitor <T> { + public T visit(NasmAdd inst); + public T visit(NasmCall inst); + public T visit(NasmDiv inst); + public T visit(NasmJe inst); + public T visit(NasmJle inst); + public T visit(NasmJne inst); + public T visit(NasmMul inst); + public T visit(NasmOr inst); + public T visit(NasmCmp inst); + public T visit(NasmInst inst); + public T visit(NasmJge inst); + public T visit(NasmJl inst); + public T visit(NasmNot inst); + public T visit(NasmPop inst); + public T visit(NasmRet inst); + public T visit(NasmXor inst); + public T visit(NasmAnd inst); + public T visit(NasmJg inst); + public T visit(NasmJmp inst); + public T visit(NasmMov inst); + public T visit(NasmPush inst); + public T visit(NasmSub inst); + public T visit(NasmEmpty inst); + public T visit(NasmInt inst); + + public T visit(NasmAddress operand); + public T visit(NasmConstant operand); + public T visit(NasmLabel operand); + public T visit(NasmRegister operand); + + public T visit(NasmResb pseudoInst); + public T visit(NasmResw pseudoInst); + public T visit(NasmResd pseudoInst); + public T visit(NasmResq pseudoInst); + public T visit(NasmRest pseudoInst); + + public T visit(NasmExp exp); + public T visit(NasmExpPlus exp); + public T visit(NasmExpMinus exp); + public T visit(NasmExpTimes exp); + +} + + diff --git a/src/nasm/NasmXor.java b/src/nasm/NasmXor.java new file mode 100644 index 0000000000000000000000000000000000000000..28a0803173c338057aed831728cc0603ce1bb796 --- /dev/null +++ b/src/nasm/NasmXor.java @@ -0,0 +1,24 @@ +package nasm; + +public class NasmXor extends NasmInst { + + public NasmXor(NasmOperand label, NasmOperand destination, NasmOperand source, String comment){ + destUse = true; + destDef = true; + srcUse = true; + this.label = label; + this.destination = destination; + this.source = source; + this.comment = comment; + } + + public <T> T accept(NasmVisitor <T> visitor) { + return visitor.visit(this); + } + + public String toString(){ + return super.formatInst(this.label, "xor", this.destination, this.source, this.comment); + } + + +} diff --git a/src/sa.cfg b/src/sa.cfg new file mode 100644 index 0000000000000000000000000000000000000000..60ff9b85148f3e6fe9b397212b275494b2853a94 --- /dev/null +++ b/src/sa.cfg @@ -0,0 +1,127 @@ +Package saParser; + +Helpers + +lettre = [['a' .. 'z'] + ['A' .. 'Z']]; +chiffre = ['0' .. '9']; +alpha = [lettre + ['_' + '$']]; +alphanum = [lettre + chiffre]; + +Tokens + +espaces = (' ' | 13 | 10 | 9)+; +commentaire= '#' [[0 .. 0xffff] - [10 + 13]]* (10 | 13 | 10 13); + + +po = '('; +pf = ')'; +saappel = 'SaAppel'; +sadecfonc = 'SaDecFonc'; +sadectab = 'SaDecTab'; +sadecvar = 'SaDecVar'; +sadecvarsimple = 'SaDecVarSimple'; +saexpadd = 'SaExpAdd'; +saexpand = 'SaExpAnd'; +saexpappel = 'SaExpAppel'; +saexpdiv = 'SaExpDiv'; +saexpequal = 'SaExpEqual'; +saexpfaux = 'SaExpFaux'; +saexpinf = 'SaExpInf'; +saexpint = 'SaExpInt'; +saexplire = 'SaExpLire'; +saexpmult = 'SaExpMult'; +saexpnot = 'SaExpNot'; +saexpor = 'SaExpOr'; +saexpsub = 'SaExpSub'; +saexpvar = 'SaExpVar'; +saexpvrai = 'SaExpVrai'; +sainstaffect = 'SaInstAffect'; +sainstbloc = 'SaInstBloc'; +sainstecriture = 'SaInstEcriture'; +sainstretour = 'SaInstRetour'; +sainstsi = 'SaInstSi'; +sainsttantque = 'SaInstTantQue'; +saldecfonc = 'SaLDecFonc'; +saldecvar = 'SaLDecVar'; +salexp = 'SaLExp'; +salinst = 'SaLInst'; +saprog = 'SaProg'; +savarindicee = 'SaVarIndicee'; +savarsimple = 'SaVarSimple'; +faux = 'faux'; +vrai = 'vrai'; +lire = 'lire'; +null = 'null'; +entier = 'entier'; +bool = 'bool'; +nul = 'nul'; +integer = chiffre+; +id = alpha alphanum*; + +Ignored Tokens + +espaces, commentaire; + +Productions + +prog = po saprog ldecvar ldecfonc pf; + + +exp = {add} po saexpadd [op1]:exp [op2]:exp pf + | {and} po saexpand [op1]:exp [op2]:exp pf + | {div} po saexpdiv [op1]:exp [op2]:exp pf + | {equal} po saexpequal [op1]:exp [op2]:exp pf + | {inf} po saexpinf [op1]:exp [op2]:exp pf + | {mult} po saexpmult [op1]:exp [op2]:exp pf + | {or} po saexpor [op1]:exp [op2]:exp pf + | {sub} po saexpsub [op1]:exp [op2]:exp pf + | {not} po saexpnot exp pf + | {appel} po saexpappel appel pf + | {var} po saexpvar var pf + | {faux} faux + | {vrai} vrai + | {int} integer + | {lire} lire + ; + +inst = {affect} po sainstaffect var exp pf + | {bloc} po sainstbloc linst pf + | {ecriture} po sainstecriture exp pf + | {retour} po sainstretour exp pf + | {si} po sainstsi exp [alors]:inst [sinon]:inst pf + | {si2} po sainstsi exp [alors]:inst null pf + | {tantque} po sainsttantque exp inst pf + | {appel} appel + ; + +ldecfonc = {rec} po saldecfonc decfonc ldecfonc pf + | {fin} null + ; + +ldecvar = {rec} po saldecvar decvar ldecvar pf + | {fin} null + ; + +lexp = {rec} po salexp exp lexp pf + | {fin} null + ; + +linst = {rec} po salinst inst linst pf + | {fin} null + ; + +decfonc = po sadecfonc id type [param]:ldecvar [variables]:ldecvar inst pf; + +decvar = {tab} po sadectab id type integer pf + | {simple} po sadecvarsimple id type pf + ; + +var = {indicee} po savarindicee id exp pf + | {simple} po savarsimple id pf; + +appel = po saappel id lexp pf; + +type = {entier} entier + | {bool} bool + | {null} nul + ; \ No newline at end of file diff --git a/src/sa/ErrorException.java b/src/sa/ErrorException.java new file mode 100644 index 0000000000000000000000000000000000000000..61963e600be7dc9fd5d631e3eae7f6a34990f16d --- /dev/null +++ b/src/sa/ErrorException.java @@ -0,0 +1,23 @@ +package sa; +import util.Error; + +public class ErrorException extends Exception{ + private Error error; + private String message; + + + public ErrorException(Error error, String message){ + this.error = error; + this.message = message; + } + + public String getMessage(){ + return message; + } + + public int getCode(){ + return error.code(); + } + + +} diff --git a/src/sa/LoadSa.java b/src/sa/LoadSa.java new file mode 100644 index 0000000000000000000000000000000000000000..209de9c85c26193b813e1b9c8c4cdc4c544cf142 --- /dev/null +++ b/src/sa/LoadSa.java @@ -0,0 +1,547 @@ +package sa; +import saParser.analysis.DepthFirstAdapter; +import saParser.lexer.Lexer; +import saParser.lexer.LexerException; +import saParser.node.*; +import saParser.parser.Parser; +import saParser.parser.ParserException; +import util.Error; +import util.Type; + +import java.io.FileReader; +import java.io.IOException; +import java.io.PushbackReader; + +public class LoadSa extends DepthFirstAdapter { + private SaProg root; + private SaNode returnValue; + private Type returnType; + + public LoadSa(String saFileName) { + PushbackReader fileReader = null; + Parser parser = null; + Start root = null; + try { + fileReader = new PushbackReader(new FileReader(saFileName)); + } catch (IOException e) { + System.err.println("cannot open input file"); + e.printStackTrace(); + } + try { + parser = new Parser(new Lexer(fileReader)); + root = parser.parse(); + } catch (ParserException e) { + System.err.println("syntax error"); + e.printStackTrace(); + System.exit(Error.SYNT.code()); + } catch (LexerException e) { + System.err.println("lexical error"); + e.printStackTrace(); + System.exit(Error.LEX.code()); + } catch (IOException e) { + e.printStackTrace(); + } + root.apply(this); + } + + public void defaultIn(Node node) + { + //System.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(Node node) + { + //System.out.println("</" + node.getClass().getSimpleName() + ">"); + } + + public SaProg getRoot(){return root;} + + + + + +// prog = po saprog ldecvar ldecfonc pf + @Override + public void caseAProg(AProg node) + { + inAProg(node); + SaLDecVar ldecVar = null; + SaLDecFonc ldecFonc = null; + if(node.getLdecvar() != null) + { + node.getLdecvar().apply(this); + ldecVar = (SaLDecVar) returnValue; + } + if(node.getLdecfonc() != null) + { + node.getLdecfonc().apply(this); + ldecFonc = (SaLDecFonc) returnValue; + } + root = new SaProg(ldecVar, ldecFonc); + outAProg(node); + } + +// exp = {add} po saexpadd [op1]:exp [op2]:exp pf + @Override + public void caseAAddExp(AAddExp node) + { + inAAddExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpAdd(op1,op2); + outAAddExp(node); + } + +// exp = {and} po saexpand [op1]:exp [op2]:exp pf + @Override + public void caseAAndExp(AAndExp node) + { + inAAndExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpAnd(op1,op2); + outAAndExp(node); + } + +// exp = {div} po saexpdiv [op1]:exp [op2]:exp pf + @Override + public void caseADivExp(ADivExp node) + { + inADivExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpDiv(op1,op2); + outADivExp(node); + } + +// exp = {equal} po saexpequal [op1]:exp [op2]:exp pf + @Override + public void caseAEqualExp(AEqualExp node) + { + inAEqualExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpEqual(op1,op2); + outAEqualExp(node); + } + +// exp = {inf} po saexpinf [op1]:exp [op2]:exp pf + @Override + public void caseAInfExp(AInfExp node) + { + inAInfExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpInf(op1,op2); + outAInfExp(node); + } + +// exp = {mult} po saexpmult [op1]:exp [op2]:exp pf + @Override + public void caseAMultExp(AMultExp node) + { + inAMultExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpMult(op1,op2); + outAMultExp(node); + } + +// exp = {or} po saexpor [op1]:exp [op2]:exp pf + @Override + public void caseAOrExp(AOrExp node) + { + inAOrExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpOr(op1,op2); + } + +// exp = {sub} po saexpsub [op1]:exp [op2]:exp pf + @Override + public void caseASubExp(ASubExp node) + { + inASubExp(node); + node.getOp1().apply(this); + SaExp op1 = (SaExp) returnValue; + node.getOp2().apply(this); + SaExp op2 = (SaExp) returnValue; + returnValue = new SaExpSub(op1,op2); + outASubExp(node); + } + +// exp = {not} po saexpnot exp pf + @Override + public void caseANotExp(ANotExp node) + { + inANotExp(node); + node.getExp().apply(this); + SaExp exp = (SaExp) returnValue; + returnValue = new SaExpNot(exp); + outANotExp(node); + } + +// exp = {appel} po saexpappel appel pf + @Override + public void caseAAppelExp(AAppelExp node) + { + inAAppelExp(node); + node.getAppel().apply(this); + SaAppel appel = (SaAppel) returnValue; + returnValue = new SaExpAppel(appel); + outAAppelExp(node); + } + +// exp = {var} po saexpvar var pf + @Override + public void caseAVarExp(AVarExp node) + { + inAVarExp(node); + node.getVar().apply(this); + SaVar var = (SaVar) returnValue; + returnValue = new SaExpVar(var); + outAVarExp(node); + } + +// exp = {faux} faux + @Override + public void caseAFauxExp(AFauxExp node) + { + inAFauxExp(node); + returnValue = new SaExpFaux(); + outAFauxExp(node); + } + +// exp = {vrai} vrai + @Override + public void caseAVraiExp(AVraiExp node) + { + inAVraiExp(node); + returnValue = new SaExpVrai(); + outAVraiExp(node); + } + +// exp = {int} integer + @Override + public void caseAIntExp(AIntExp node) + { + inAIntExp(node); + int value = Integer.parseInt(node.getInteger().getText()); + returnValue = new SaExpInt(value); + outAIntExp(node); + } + +// exp = {lire} lire + @Override + public void caseALireExp(ALireExp node) + { + inALireExp(node); + returnValue = new SaExpLire(); + outALireExp(node); + } + +// inst = {affect} po sainstaffect var exp pf + @Override + public void caseAAffectInst(AAffectInst node) + { + inAAffectInst(node); + node.getVar().apply(this); + SaVar var = (SaVar) returnValue; + node.getExp().apply(this); + SaExp exp = (SaExp) returnValue; + returnValue = new SaInstAffect(var, exp); + outAAffectInst(node); + } + +// inst = {bloc} po sainstbloc linst pf + @Override + public void caseABlocInst(ABlocInst node) + { + inABlocInst(node); + node.getLinst().apply(this); + SaLInst linst = (SaLInst) returnValue; + returnValue = new SaInstBloc(linst); + outABlocInst(node); + } + +// inst = {ecriture} po sainstecriture exp pf + @Override + public void caseAEcritureInst(AEcritureInst node) + { + inAEcritureInst(node); + node.getExp().apply(this); + SaExp exp = (SaExp) returnValue; + returnValue = new SaInstEcriture(exp); + outAEcritureInst(node); + } + +// inst = {retour} po sainstretour exp pf + @Override + public void caseARetourInst(ARetourInst node) + { + inARetourInst(node); + node.getExp().apply(this); + SaExp exp = (SaExp) returnValue; + returnValue = new SaInstRetour(exp); + outARetourInst(node); + } + +// inst = {si} po sainstsi exp [alors]:inst [sinon]:inst pf + @Override + public void caseASiInst(ASiInst node) + { + inASiInst(node); + node.getExp().apply(this); + SaExp si = (SaExp) returnValue; + node.getAlors().apply(this); + SaInst alors = (SaInst) returnValue; + SaInst sinon = null; + if(node.getSinon() != null) + { + node.getSinon().apply(this); + sinon = (SaInst) returnValue; + } + returnValue = new SaInstSi(si, alors, sinon); + outASiInst(node); + } + + // inst = {si2} po sainstsi exp [alors]:inst null pf + + @Override + public void caseASi2Inst(ASi2Inst node) + { + inASi2Inst(node); + node.getExp().apply(this); + SaExp si = (SaExp) returnValue; + node.getAlors().apply(this); + SaInst alors = (SaInst) returnValue; + returnValue = new SaInstSi(si, alors, null); + outASi2Inst(node); + } + + + // inst = {tantque} po sainsttantque exp inst pf + @Override + public void caseATantqueInst(ATantqueInst node) + { + inATantqueInst(node); + node.getExp().apply(this); + SaExp test = (SaExp) returnValue; + node.getInst().apply(this); + SaInst bloc = (SaInst) returnValue; + returnValue = new SaInstTantQue(test, bloc); + outATantqueInst(node); + } + +// ldecfonc = {rec} po saldecfonc decfonc ldecfonc pf + @Override + public void caseARecLdecfonc(ARecLdecfonc node) + { + inARecLdecfonc(node); + node.getDecfonc().apply(this); + SaDecFonc dec = (SaDecFonc) returnValue; + node.getLdecfonc().apply(this); + SaLDecFonc ldec = (SaLDecFonc) returnValue; + returnValue = new SaLDecFonc(dec, ldec); + outARecLdecfonc(node); + } + +// ldecfonc = {fin} null + @Override + public void caseAFinLdecfonc(AFinLdecfonc node) + { + inAFinLdecfonc(node); + returnValue = null; + outAFinLdecfonc(node); + } + +// ldecvar = {rec} po saldecvar decvar ldecvar pf + @Override + public void caseARecLdecvar(ARecLdecvar node) + { + inARecLdecvar(node); + node.getDecvar().apply(this); + SaDecVar dec = (SaDecVar) returnValue; + node.getLdecvar().apply(this); + SaLDecVar ldec = (SaLDecVar) returnValue; + returnValue = new SaLDecVar(dec, ldec); + outARecLdecvar(node); + } + +// ldecvar = {fin} null + @Override + public void caseAFinLdecvar(AFinLdecvar node) + { + inAFinLdecvar(node); + returnValue = null; + outAFinLdecvar(node); + } + +// lexp = {rec} po salexp exp lexp pf + @Override + public void caseARecLexp(ARecLexp node) + { + inARecLexp(node); + node.getExp().apply(this); + SaExp exp = (SaExp) returnValue; + node.getLexp().apply(this); + SaLExp lexp = (SaLExp) returnValue; + returnValue = new SaLExp(exp, lexp); + outARecLexp(node); + } + +// lexp = {fin} null + @Override + public void caseAFinLexp(AFinLexp node) + { + inAFinLexp(node); + returnValue = null; + outAFinLexp(node); + } + +// linst = {rec} po salinst inst linst pf + @Override + public void caseARecLinst(ARecLinst node) + { + inARecLinst(node); + node.getInst().apply(this); + SaInst inst = (SaInst) returnValue; + node.getLinst().apply(this); + SaLInst linst = (SaLInst) returnValue; + returnValue = new SaLInst(inst, linst); + outARecLinst(node); + } + +// linst = {fin} null + @Override + public void caseAFinLinst(AFinLinst node) + { + inAFinLinst(node); + returnValue = null; + outAFinLinst(node); + } + +// decfonc = po sadecfonc id [param]:ldecvar [variables]:ldecvar inst type pf + @Override + public void caseADecfonc(ADecfonc node) + { + inADecfonc(node); + String foncName = node.getId().getText(); + node.getParam().apply(this); + SaLDecVar params = (SaLDecVar) returnValue; + node.getVariables().apply(this); + SaLDecVar variables = (SaLDecVar) returnValue; + node.getInst().apply(this); + SaInst corps = (SaInst) returnValue; + node.getType().apply(this); + Type type = returnType; + returnValue = new SaDecFonc(foncName, type, params, variables, corps); + outADecfonc(node); + } + +// decvar = {tab} po sadectab id integer type pf + @Override + public void caseATabDecvar(ATabDecvar node) + { + inATabDecvar(node); + String nom = node.getId().getText(); + int taille = Integer.parseInt(node.getInteger().getText()); + node.getType().apply(this); + Type type = returnType; + returnValue = new SaDecTab(nom, type, taille); + outATabDecvar(node); + } + +// decvar = {simple} po sadecvarsimple id type pf + @Override + public void caseASimpleDecvar(ASimpleDecvar node) + { + inASimpleDecvar(node); + String nom = node.getId().getText(); + node.getType().apply(this); + Type type = returnType; + returnValue = new SaDecVarSimple(nom, type); + outASimpleDecvar(node); + } + + // var = {indicee} po savarindicee id exp pf + @Override + public void caseAIndiceeVar(AIndiceeVar node) + { + inAIndiceeVar(node); + String nom = node.getId().getText(); + node.getExp().apply(this); + SaExp indice = (SaExp) returnValue; + returnValue = new SaVarIndicee(nom, indice); + outAIndiceeVar(node); + } + + // var = {simple} po savarsimple id pf + @Override + public void caseASimpleVar(ASimpleVar node) + { + inASimpleVar(node); + String nom = node.getId().getText(); + returnValue = new SaVarSimple(nom); + outASimpleVar(node); + } + +// appel = po saappel id lexp pf + @Override + public void caseAAppel(AAppel node) + { + inAAppel(node); + String nom = node.getId().getText(); + node.getLexp().apply(this); + SaLExp arguments = (SaLExp) returnValue; + returnValue = new SaAppel(nom, arguments); + outAAppel(node); + } + +// type = {entier} entier + @Override + public void caseAEntierType(AEntierType node) + { + inAEntierType(node); + returnType = Type.ENTIER; + outAEntierType(node); + } + +// type = {bool} bool + @Override + public void caseABoolType(ABoolType node) + { + inABoolType(node); + returnType = Type.BOOL; + outABoolType(node); + } + +// type = {null} nul + @Override + public void caseANullType(ANullType node) + { + inANullType(node); + returnType = Type.NUL; + outANullType(node); + } +} + + + + + + diff --git a/src/sa/SaAppel.java b/src/sa/SaAppel.java new file mode 100644 index 0000000000000000000000000000000000000000..84a3f776e1a22e1576cef5ae7617683f99adf327 --- /dev/null +++ b/src/sa/SaAppel.java @@ -0,0 +1,33 @@ +package sa; +import ts.*; +import util.Type; + + +public class SaAppel implements SaExp, SaInst{ + private String nom; + private SaLExp arguments; + public TsItemFct tsItem; + + public SaAppel(String nom, SaLExp arguments){ + this.nom = nom; + this.arguments = arguments; + this.tsItem = null; + } + + public String getNom(){return this.nom;} + public SaLExp getArguments(){return this.arguments;} + + + public Type getType(){ + return tsItem.typeRetour; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName()+ " " + nom + " " + arguments + ")"; + } +} diff --git a/src/sa/SaCheckLinkage.java b/src/sa/SaCheckLinkage.java new file mode 100644 index 0000000000000000000000000000000000000000..f25f01789debecd89aea3c1023b5dac5e3b70e42 --- /dev/null +++ b/src/sa/SaCheckLinkage.java @@ -0,0 +1,42 @@ +package sa; + +import util.Error; + +public class SaCheckLinkage extends SaDepthFirstVisitor <Void>{ + + public Void visit(SaDecFonc node) throws Exception { + defaultIn(node); + if (node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaDecFonc"); + if(node.getParametres() != null) node.getParametres().accept(this); + if(node.getVariable() != null) node.getVariable().accept(this); + if(node.getCorps() != null) node.getCorps().accept(this); + defaultOut(node); + return null; + + } + + public Void visit(SaDecVarSimple node) throws ErrorException { + if (node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaDecVarSimple"); + return null; + } + + public Void visit(SaDecTab node) throws ErrorException { + if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaDecTab"); + return null; + } + + public Void visit(SaAppel node) throws ErrorException{ + if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaAppel"); + return null; + } + + public Void visit(SaVarSimple node) throws ErrorException{ + if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaVarSimple"); + return null; + } + public Void visit(SaVarIndicee node) throws ErrorException{ + if(node.tsItem == null) throw new ErrorException(Error.TS, "linkage error in SaVarIndicee"); + return null; + } +} + diff --git a/src/sa/SaDec.java b/src/sa/SaDec.java new file mode 100644 index 0000000000000000000000000000000000000000..275b4b6d00d097645a8e3f26fe73cf9599e5fd5a --- /dev/null +++ b/src/sa/SaDec.java @@ -0,0 +1,5 @@ +package sa; + +public interface SaDec extends SaNode { + public String getNom(); +} diff --git a/src/sa/SaDecFonc.java b/src/sa/SaDecFonc.java new file mode 100644 index 0000000000000000000000000000000000000000..7f4b817756c74306030039cecf3df83db5c309de --- /dev/null +++ b/src/sa/SaDecFonc.java @@ -0,0 +1,34 @@ +package sa; +import ts.*; +import util.Type; + +public class SaDecFonc implements SaDec{ + private String nom; + private SaLDecVar parametres; + private SaLDecVar variables; + private SaInst corps; + private Type typeRetour; + public TsItemFct tsItem; + + public SaDecFonc(String nom, Type typeRetour, SaLDecVar parametres, SaLDecVar variables, SaInst corps){ + this.nom = nom; + this.typeRetour = typeRetour; + this.parametres = parametres; + this.variables = variables; + this.corps = corps; + this.tsItem = null; + } + + public String getNom(){return this.nom;} + public Type getTypeRetour(){return this.typeRetour;} + public SaLDecVar getParametres(){return this.parametres;} + public SaLDecVar getVariable(){return this.variables;} + public SaInst getCorps(){return this.corps;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + public String toString(){ + return "(" + this.getClass().getSimpleName() + " " + nom + " " + typeRetour + " " + parametres + " " + variables + " " + corps + ")"; + } +} diff --git a/src/sa/SaDecTab.java b/src/sa/SaDecTab.java new file mode 100644 index 0000000000000000000000000000000000000000..8eaf2094c4e567fb0fa25e14eb2390c2ebe5090c --- /dev/null +++ b/src/sa/SaDecTab.java @@ -0,0 +1,31 @@ +package sa; +import ts.*; +import util.Type; + +public class SaDecTab implements SaDecVar{ + private String nom; + private int taille; + private Type type; + public TsItemVar tsItem; + + public SaDecTab(String nom, Type type, int taille){ + this.nom = nom; + this.type = type; + this.taille = taille; + this.tsItem = null; + } + + public String getNom(){return this.nom;} + public int getTaille(){return this.taille;} + public Type getType(){return this.type;} + public TsItemVar getTsItem(){return this.tsItem;} + public void setTsItem(TsItemVar tsItem){this.tsItem = tsItem;} + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + nom + " " + type + " " + taille + ")"; + } +} diff --git a/src/sa/SaDecVar.java b/src/sa/SaDecVar.java new file mode 100644 index 0000000000000000000000000000000000000000..9cc6f02a87b83e5a3692d4c9fbfab6533acb5386 --- /dev/null +++ b/src/sa/SaDecVar.java @@ -0,0 +1,11 @@ +package sa; +import util.Type; +import ts.*; + +public interface SaDecVar extends SaNode { + public String getNom(); + public Type getType(); + public TsItemVar getTsItem(); + public void setTsItem(TsItemVar tsItem); + +} diff --git a/src/sa/SaDecVarSimple.java b/src/sa/SaDecVarSimple.java new file mode 100644 index 0000000000000000000000000000000000000000..557cf28b32d934981c05104457e587a433767a00 --- /dev/null +++ b/src/sa/SaDecVarSimple.java @@ -0,0 +1,29 @@ +package sa; +import ts.*; +import util.Type; + +public class SaDecVarSimple implements SaDecVar{ + private String nom; + private Type type; + public TsItemVar tsItem; + + public SaDecVarSimple(String nom, Type type){ + this.nom = nom; + this.type = type; + this.tsItem = null; + } + + public String getNom(){return this.nom;} + public Type getType(){return this.type;} + public TsItemVar getTsItem(){return this.tsItem;} + public void setTsItem(TsItemVar tsItem){this.tsItem = tsItem;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + nom + " " + type + ")"; + } +} diff --git a/src/sa/SaDepthFirstVisitor.java b/src/sa/SaDepthFirstVisitor.java new file mode 100644 index 0000000000000000000000000000000000000000..ded93ad194c4d1bc1f81c6f76a48c900262ce527 --- /dev/null +++ b/src/sa/SaDepthFirstVisitor.java @@ -0,0 +1,386 @@ +package sa; + + +// P -> LDEC LDEC + +// DEC -> var id taille +// DEC -> fct id LDEC LDEC LINST +// DEC -> var id + +// LDEC -> DEC LDEC +// LDEC -> null + +// VAR ->simple id +// VAR ->indicee id EXP + +// LINST -> INST LINST +// LINST -> null + +// INST -> aff VAR EXP +// INST -> si EXP LINST LINST +// INST -> tq EXP LINST +// INST -> app APP +// INST -> ret EXP +// INST -> ecr EXP + +// APP -> id LEXP + +// LEXP -> EXP LEXP +// LEXP -> null + +// EXP -> op2 EXP EXP +// EXP -> op1 EXP +// EXP -> VAR +// EXP -> entier +// EXP -> APP +// EXP -> lire + + +//********** + +// VAR ->simple id +// VAR ->indicee id EXP + +// LINST -> INST LINST +// LINST -> null + +// INST -> aff VAR EXP +// INST -> si EXP LINST LINST +// INST -> tq EXP LINST +// INST -> app APP +// INST -> ecr EXP + +// APP -> id LEXP + +// LEXP -> EXP LEXP +// LEXP -> null + + +// EXP -> op1 EXP +// EXP -> VAR + +// EXP -> lire + + +public class SaDepthFirstVisitor <T> implements SaVisitor <T>{ + + // private NouvelleClasse x; + public void defaultIn(SaNode node) + { + } + + public void defaultOut(SaNode node) + { + } + + // P -> LDEC LDEC + public T visit(SaProg node) throws Exception + { + defaultIn(node); + if(node.getVariables() != null) + node.getVariables().accept(this); + if(node.getFonctions() != null) + node.getFonctions().accept(this); + defaultOut(node); + return null; + } + + // DEC -> var id taille + public T visit(SaDecTab node) throws Exception{ + defaultIn(node); + defaultOut(node); + return null; + } + + public T visit(SaExp node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + // EXP -> entier + public T visit(SaExpInt node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + // EXP -> vrai + public T visit(SaExpVrai node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + // EXP -> faux + public T visit(SaExpFaux node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + public T visit(SaExpVar node) throws Exception + { + defaultIn(node); + node.getVar().accept(this); + defaultOut(node); + return null; + } + + public T visit(SaInstEcriture node) throws Exception + { + defaultIn(node); + node.getArg().accept(this); + defaultOut(node); + return null; + } + + public T visit(SaInstTantQue node) throws Exception + { + defaultIn(node); + node.getTest().accept(this); + if (node.getFaire() != null) + node.getFaire().accept(this); + defaultOut(node); + return null; + } + public T visit(SaLInst node) throws Exception + { + defaultIn(node); + if(node != null){ + if(node.getTete() != null)node.getTete().accept(this); + if(node.getQueue() != null) node.getQueue().accept(this); + } + defaultOut(node); + return null; + } + + // DEC -> fct id LDEC LDEC LINST + public T visit(SaDecFonc node) throws Exception + { + defaultIn(node); + if(node.getParametres() != null) node.getParametres().accept(this); + if(node.getVariable() != null) node.getVariable().accept(this); + if(node.getCorps() != null) node.getCorps().accept(this); + defaultOut(node); + return null; + } + + // DEC -> var id + public T visit(SaDecVar node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + public T visit(SaInstAffect node) throws Exception + { + defaultIn(node); + node.getLhs().accept(this); + node.getRhs().accept(this); + defaultOut(node); + return null; + } + + // LDEC -> DEC LDEC + // LDEC -> null + /* public T visit(SaLDec node) throws Exception + { + defaultIn(node); + node.getTete().accept(this); + if(node.getQueue() != null) node.getQueue().accept(this); + defaultOut(node); + return null; + }*/ + + public T visit(SaLDecVar node) throws Exception + { + defaultIn(node); + node.getTete().accept(this); + if(node.getQueue() != null) node.getQueue().accept(this); + defaultOut(node); + return null; + } + + public T visit(SaLDecFonc node) throws Exception + { + defaultIn(node); + node.getTete().accept(this); + if(node.getQueue() != null) node.getQueue().accept(this); + defaultOut(node); + return null; + } + + public T visit(SaVarSimple node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + public T visit(SaAppel node) throws Exception + { + defaultIn(node); + if(node.getArguments() != null) node.getArguments().accept(this); + defaultOut(node); + return null; + } + + public T visit(SaExpAppel node) throws Exception + { + defaultIn(node); + node.getVal().accept(this); + defaultOut(node); + return null; + } + + // EXP -> add EXP EXP + public T visit(SaExpAdd node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + // EXP -> sub EXP EXP + public T visit(SaExpSub node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + // EXP -> mult EXP EXP + public T visit(SaExpMult node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + // EXP -> div EXP EXP + public T visit(SaExpDiv node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + // EXP -> inf EXP EXP + public T visit(SaExpInf node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + // EXP -> eq EXP EXP + public T visit(SaExpEqual node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + // EXP -> and EXP EXP + public T visit(SaExpAnd node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + + // EXP -> or EXP EXP + public T visit(SaExpOr node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + node.getOp2().accept(this); + defaultOut(node); + return null; + } + + // EXP -> not EXP + public T visit(SaExpNot node) throws Exception + { + defaultIn(node); + node.getOp1().accept(this); + defaultOut(node); + return null; + } + + + public T visit(SaExpLire node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + public T visit(SaInstBloc node) throws Exception + { + defaultIn(node); + node.getVal().accept(this); + defaultOut(node); + return null; + } + + public T visit(SaInstSi node) throws Exception + { + defaultIn(node); + node.getTest().accept(this); + if (node.getAlors() != null) + node.getAlors().accept(this); + if(node.getSinon() != null) node.getSinon().accept(this); + defaultOut(node); + return null; + } + +// INST -> ret EXP + public T visit(SaInstRetour node) throws Exception + { + defaultIn(node); + node.getVal().accept(this); + defaultOut(node); + return null; + } + + + public T visit(SaLExp node) throws Exception + { + defaultIn(node); + node.getTete().accept(this); + if(node.getQueue() != null) + node.getQueue().accept(this); + defaultOut(node); + return null; + } + public T visit(SaVarIndicee node) throws Exception + { + defaultIn(node); + node.getIndice().accept(this); + defaultOut(node); + return null; + } + +} diff --git a/src/sa/SaEnvironment.java b/src/sa/SaEnvironment.java new file mode 100644 index 0000000000000000000000000000000000000000..1c85759e6227e50911e0e656b6835235672e5483 --- /dev/null +++ b/src/sa/SaEnvironment.java @@ -0,0 +1,33 @@ +package sa; +import java.util.*; +import ts.*; +import util.Memory; + +public class SaEnvironment { + public Memory vars; + public Memory args; + public TypeVal returnValue; + + public SaEnvironment (TsItemFct fct) + { + SaLExp lArgs = null; + Ts localTable = fct.getTable(); + int i = 0; + + args = new Memory(localTable.getAdrArgCourante(), 0); + vars = new Memory(localTable.getAdrVarCourante(), 0); + + // args = new Memory(200, 0); + // vars = new Memory(200, 0); + + returnValue = null; + // System.out.println("allocation d'un nouvel environnement, fonction " + fct.getIdentif()); + // System.out.println("dim var = " + localTable.getAdrVarCourante()); + // System.out.println("dim arg = " + localTable.getAdrArgCourante()); + + } + + + public TypeVal getReturnValue(){return returnValue;} + public void setReturnValue(TypeVal typeVal){returnValue = typeVal;} +} diff --git a/src/sa/SaEval.java b/src/sa/SaEval.java new file mode 100644 index 0000000000000000000000000000000000000000..b66416e63337fe2c5c90868ac124bb2ea9b0097a --- /dev/null +++ b/src/sa/SaEval.java @@ -0,0 +1,465 @@ +package sa; +import java.util.*; +import java.io.*; +import ts.*; +import util.Memory; +import util.Type; + + +public class SaEval extends SaDepthFirstVisitor <TypeVal> { + private Ts tableGlobale; + private SaEnvironment curEnv; + private Memory varGlob; + private ArrayList<String> programOutput = new ArrayList<String>(); + private boolean stop; + + public SaEval(SaNode root, Ts tableGlobale){ + this.tableGlobale = tableGlobale; + curEnv = null; + varGlob = new Memory(tableGlobale.getAdrVarCourante(), 0); + stop = false; + SaAppel appelMain = new SaAppel("main", null); + appelMain.tsItem = tableGlobale.getFct("main"); + + try{ + appelMain.accept(this); + } catch(Exception e){} + } + + public TypeVal getVar(SaVarSimple saVar){ + TsItemVarSimple tsItem = saVar.getTsItem(); + return getVar(tsItem); + } + + public TypeVal getVar(TsItemVarSimple tsItem){ + Memory container = null; + if(tsItem.portee == this.tableGlobale) // variable globale + container = varGlob; + else + container = (tsItem.isParam)? curEnv.args : curEnv.vars; + if(tsItem.type == Type.ENTIER) + return new TypeVal(container.readInt(tsItem.adresse)); + // if(tsItem.type == Type.BOOL) + return new TypeVal(container.readBoolean(tsItem.adresse)); + } + + public void setVar(SaVarSimple saVar, TypeVal typeVal){ + TsItemVarSimple tsItem = saVar.getTsItem(); + setVar(tsItem, typeVal); + } + + + public void setVar(TsItemVarSimple tsItem, TypeVal typeVal){ + Memory container = null; + // trois cas possibles : une variable locale, une variable globale ou un argument + if(tsItem.portee == this.tableGlobale) // variable globale + container = varGlob; + else if (tsItem.isParam) + container = curEnv.args; + else + container = curEnv.vars; + + if(tsItem.type == Type.ENTIER) + container.writeInt(tsItem.adresse, typeVal.valInt); + if(tsItem.type == Type.BOOL) + container.writeBoolean(tsItem.adresse, typeVal.valBool); + } + + private TypeVal getVarGlobIndicee(SaVarIndicee saVarIndicee, TypeVal indice){ + TsItemVar tsItem = saVarIndicee.getTsItem(); + if(tsItem.type == Type.ENTIER) + return new TypeVal(varGlob.readInt(tsItem.adresse + tsItem.type.taille() * indice.valInt)); + // if(tsItem.type == Type.BOOL) + return new TypeVal(varGlob.readBoolean(tsItem.adresse + tsItem.type.taille() * indice.valInt)); + } + + private void setVarGlobIndicee(SaVarIndicee saVarIndicee, TypeVal indice, TypeVal typeVal){ + TsItemVar tsItem = saVarIndicee.getTsItem(); + if(tsItem.type == Type.ENTIER) + varGlob.writeInt(tsItem.adresse + tsItem.type.taille() * indice.valInt, typeVal.valInt); + if(tsItem.type == Type.BOOL) + varGlob.writeBoolean(tsItem.adresse + tsItem.type.taille() * indice.valInt , typeVal.valBool); + } + + + public void affiche(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".saout"; + out = new PrintStream(fileName); + } catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + for (String line : programOutput) + out.println(line); + } + + + + public void defaultIn(SaNode node) + { + } + + public void defaultOut(SaNode node) + { + } + + // P -> LDEC LDEC + public TypeVal visit(SaProg node) throws Exception + { + defaultIn(node); + System.out.println("dans prog"); + if(node.getVariables() != null) + node.getVariables().accept(this); + if(node.getFonctions() != null) + node.getFonctions().accept(this); + defaultOut(node); + return null; + } + + // DEC -> var id taille + public TypeVal visit(SaDecTab node) throws Exception{ + defaultIn(node); + defaultOut(node); + return null; + } + + public TypeVal visit(SaExp node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + // EXP -> entier + public TypeVal visit(SaExpInt node) throws Exception + { + defaultIn(node); + defaultOut(node); + return new TypeVal(node.getVal()); + } + + + // EXP -> vrai + public TypeVal visit(SaExpVrai node) throws Exception + { + defaultIn(node); + defaultOut(node); + return new TypeVal(true); + } + + // EXP -> faux + public TypeVal visit(SaExpFaux node) throws Exception + { + defaultIn(node); + defaultOut(node); + return new TypeVal(false); + } + + public TypeVal visit(SaExpVar node) throws Exception + { + defaultIn(node); + TypeVal typeVal = node.getVar().accept(this); + defaultOut(node); + return typeVal; + } + + public TypeVal visit(SaInstEcriture node) throws Exception + { + defaultIn(node); + TypeVal arg = node.getArg().accept(this); + if(arg.type == Type.ENTIER) + programOutput.add(String.valueOf(arg.valInt)); + else if(arg.type == Type.BOOL){ + if(arg.valBool == true) + programOutput.add(String.valueOf(1)); + else + programOutput.add(String.valueOf(0)); + } + defaultOut(node); + return null; + } + + public TypeVal visit(SaInstTantQue node) throws Exception + { + defaultIn(node); + TypeVal test = node.getTest().accept(this); + while (test.valBool == true){ + if (node.getFaire() != null) + node.getFaire().accept(this); + else{ + System.out.println("Infinite loop detected, breaking out"); + break; + } + test = node.getTest().accept(this); + } + defaultOut(node); + return null; + } + + public TypeVal visit(SaLInst node) throws Exception + { + defaultIn(node); + stop = false; + TypeVal valRet = node.getTete().accept(this); + if(!stop && node.getQueue() != null) node.getQueue().accept(this); + defaultOut(node); + return null; + } + + // DEC -> fct id LDEC LDEC LINST + public TypeVal visit(SaDecFonc node) throws Exception + { + defaultIn(node); + if(node.getParametres() != null) node.getParametres().accept(this); + if(node.getVariable() != null) node.getVariable().accept(this); + node.getCorps().accept(this); + defaultOut(node); + return null; + } + + // DEC -> var id + public TypeVal visit(SaDecVar node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + public TypeVal visit(SaInstAffect node) throws Exception + { + defaultIn(node); + TypeVal typeVal = node.getRhs().accept(this); + if(node.getLhs() instanceof SaVarIndicee){ // c'est une case de tableau, donc forcément globale + SaVarIndicee lhsIndicee = (SaVarIndicee) node.getLhs(); + TypeVal indice = lhsIndicee.getIndice().accept(this); + setVarGlobIndicee(lhsIndicee, indice, typeVal); + } else{ + setVar((SaVarSimple) node.getLhs(), typeVal); + } + + defaultOut(node); + return null; + } + + // LDEC -> DEC LDEC + // LDEC -> null + /* public TypeVal visit(SaLDec node) throws Exception + { + defaultIn(node); + node.getTete().accept(this); + if(node.getQueue() != null) node.getQueue().accept(this); + defaultOut(node); + return null; + }*/ + + public TypeVal visit(SaVarSimple node) throws Exception + { + defaultIn(node); + TypeVal typeVal = getVar(node); + defaultOut(node); + return typeVal; + } + + public TypeVal visit(SaAppel node) throws Exception + { + defaultIn(node); + TsItemFct fct = node.tsItem; + SaLExp lArgs = null; + SaLDecVar lParam = null; + Ts localTable = fct.getTable(); + // on construit la liste des arguments d'appel de la fonction + ArrayList<TypeVal> listeArguments = new ArrayList<TypeVal>(); + for(lArgs = node.getArguments(); lArgs != null; lArgs = lArgs.getQueue()){ + listeArguments.add(lArgs.getTete().accept(this)); + } + + //on sauvegarde de l'environnement courant pour le restaurer après l'appel + SaEnvironment oldEnv = curEnv; + // on crée un nouvel environnement pour la fonction appelée + // le nouvel environnement est l'environnement courant + curEnv = new SaEnvironment(fct); + + // on stocke les valeurs des arguments dans l'environnement + int n = 0; + for(lParam = fct.saDecFonc.getParametres(); lParam != null; lParam = lParam.getQueue()){ + setVar((TsItemVarSimple)((SaDecVar)lParam.getTete()).getTsItem(), listeArguments.get(n)); + n++; + } + // on exécute le corps de la fonction + if(fct.saDecFonc.getCorps() != null) + fct.saDecFonc.getCorps().accept(this); + + // on récupère la valeur de retour + TypeVal returnValue = curEnv.getReturnValue(); + + //restauration de l'environnement d'avant appel + curEnv = oldEnv; + defaultOut(node); + return returnValue; + } + + public TypeVal visit(SaExpAppel node) throws Exception + { + defaultIn(node); + TypeVal typeVal = node.getVal().accept(this); + defaultOut(node); + return typeVal; + } + + // EXP -> add EXP EXP + public TypeVal visit(SaExpAdd node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + return new TypeVal(op1.valInt + op2.valInt); + } + + // EXP -> sub EXP EXP + public TypeVal visit(SaExpSub node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + return new TypeVal(op1.valInt - op2.valInt); + } + + // EXP -> mult EXP EXP + public TypeVal visit(SaExpMult node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + return new TypeVal(op1.valInt * op2.valInt); + } + + // EXP -> div EXP EXP + public TypeVal visit(SaExpDiv node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + return new TypeVal((int) op1.valInt / op2.valInt); + } + + // EXP -> inf EXP EXP + public TypeVal visit(SaExpInf node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + return new TypeVal((op1.valInt < op2.valInt)? true : false); + } + + // EXP -> eq EXP EXP + public TypeVal visit(SaExpEqual node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + if(op1.type == Type.ENTIER) + return new TypeVal((op1.valInt == op2.valInt)? true : false); + else + return new TypeVal((op1.valBool == op2.valBool)? true : false); + } + + // EXP -> and EXP EXP + public TypeVal visit(SaExpAnd node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + return new TypeVal(op1.valBool && op2.valBool); + } + + // EXP -> or EXP EXP + public TypeVal visit(SaExpOr node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + TypeVal op2 = node.getOp2().accept(this); + defaultOut(node); + return new TypeVal(op1.valBool || op2.valBool); + } + + // EXP -> not EXP + public TypeVal visit(SaExpNot node) throws Exception + { + defaultIn(node); + TypeVal op1 = node.getOp1().accept(this); + defaultOut(node); + return new TypeVal(!op1.valBool); + } + + + public TypeVal visit(SaExpLire node) throws Exception + { + defaultIn(node); + defaultOut(node); + return null; + } + + public TypeVal visit(SaInstBloc node) throws Exception + { + defaultIn(node); + node.getVal().accept(this); + defaultOut(node); + return null; + } + + public TypeVal visit(SaInstSi node) throws Exception + { + defaultIn(node); + TypeVal test = node.getTest().accept(this); + if(test.valBool && node.getAlors() != null) + node.getAlors().accept(this); + if(!test.valBool && node.getSinon() != null) + node.getSinon().accept(this); + defaultOut(node); + return null; + } + +// INST -> ret EXP + public TypeVal visit(SaInstRetour node) throws Exception + { + defaultIn(node); + curEnv.setReturnValue(node.getVal().accept(this)); + stop = true; + defaultOut(node); + return null; + } + + + public TypeVal visit(SaLExp node) throws Exception + { + defaultIn(node); + node.getTete().accept(this); + if(node.getQueue() != null) + node.getQueue().accept(this); + defaultOut(node); + return null; + } + + public TypeVal visit(SaVarIndicee node) throws Exception + { + defaultIn(node); + node.getIndice().accept(this); + TypeVal indice = node.getIndice().accept(this); + defaultOut(node); + return getVarGlobIndicee(node, indice); + } + +} diff --git a/src/sa/SaExp.java b/src/sa/SaExp.java new file mode 100644 index 0000000000000000000000000000000000000000..81cbf3cd71f316298250651539dfb8addb9f692c --- /dev/null +++ b/src/sa/SaExp.java @@ -0,0 +1,6 @@ +package sa; +import util.Type; + +public interface SaExp extends SaNode { + public Type getType(); +} diff --git a/src/sa/SaExpAdd.java b/src/sa/SaExpAdd.java new file mode 100644 index 0000000000000000000000000000000000000000..0041eed4950087de222de4c9739a438e40b3d301 --- /dev/null +++ b/src/sa/SaExpAdd.java @@ -0,0 +1,26 @@ +package sa; +import util.Type; + +public class SaExpAdd implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpAdd(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.ENTIER; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + public String toString(){ + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpAnd.java b/src/sa/SaExpAnd.java new file mode 100644 index 0000000000000000000000000000000000000000..df94c5b74eddbefb67adfd2fa7b3f0eb1357c057 --- /dev/null +++ b/src/sa/SaExpAnd.java @@ -0,0 +1,26 @@ +package sa; +import util.Type; + +public class SaExpAnd implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpAnd(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.BOOL; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpAppel.java b/src/sa/SaExpAppel.java new file mode 100644 index 0000000000000000000000000000000000000000..611aa6a106ea92f6dd2198b5706294cf127dd00d --- /dev/null +++ b/src/sa/SaExpAppel.java @@ -0,0 +1,25 @@ +package sa; +import util.Type; + +public class SaExpAppel implements SaExp{ + private SaAppel val; + + public SaExpAppel(SaAppel val){ + this.val = val; + } + + public SaAppel getVal(){return this.val;} + + public Type getType(){ + return val.getType(); + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + val + ")"; + } +} diff --git a/src/sa/SaExpDiv.java b/src/sa/SaExpDiv.java new file mode 100644 index 0000000000000000000000000000000000000000..cc2db6e65ad14122a34b40d2b79f5ba9a6abe3c0 --- /dev/null +++ b/src/sa/SaExpDiv.java @@ -0,0 +1,27 @@ +package sa; +import util.Type; + +public class SaExpDiv implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpDiv(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.ENTIER; + } + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpEqual.java b/src/sa/SaExpEqual.java new file mode 100644 index 0000000000000000000000000000000000000000..01eeb010443570e08ce02b43b5af0834c8df4bef --- /dev/null +++ b/src/sa/SaExpEqual.java @@ -0,0 +1,27 @@ +package sa; +import util.Type; + +public class SaExpEqual implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpEqual(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.BOOL; + } + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpFaux.java b/src/sa/SaExpFaux.java new file mode 100644 index 0000000000000000000000000000000000000000..125956f06d4a0c057364ef77e4ad44034b31eb01 --- /dev/null +++ b/src/sa/SaExpFaux.java @@ -0,0 +1,28 @@ +package sa; +import util.Type; + +public class SaExpFaux implements SaExp{ + private final boolean val; + + public SaExpFaux(){ + this.val = false; + } + + public boolean getVal(){ + return this.val; + } + + public Type getType(){ + return Type.BOOL; + } + + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "faux"; + } +} diff --git a/src/sa/SaExpInf.java b/src/sa/SaExpInf.java new file mode 100644 index 0000000000000000000000000000000000000000..1f7c54a50048cd9745749d5c9dec52b6c89522a1 --- /dev/null +++ b/src/sa/SaExpInf.java @@ -0,0 +1,28 @@ +package sa; +import util.Type; + +public class SaExpInf implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpInf(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.BOOL; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception { + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpInt.java b/src/sa/SaExpInt.java new file mode 100644 index 0000000000000000000000000000000000000000..10bd6d6b6b674fed031f384502667ffc3c1d6717 --- /dev/null +++ b/src/sa/SaExpInt.java @@ -0,0 +1,26 @@ +package sa; +import util.Type; + +public class SaExpInt implements SaExp{ + private int val; + + public SaExpInt(int val){ + this.val = val; + } + + public int getVal(){ + return this.val; + } + + public Type getType(){ + return Type.ENTIER; + } + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return Integer.toString(val); + } +} diff --git a/src/sa/SaExpLire.java b/src/sa/SaExpLire.java new file mode 100644 index 0000000000000000000000000000000000000000..53d8520143f187cf397e344a70f19a3fd72d26b6 --- /dev/null +++ b/src/sa/SaExpLire.java @@ -0,0 +1,21 @@ +package sa; +import util.Type; + +public class SaExpLire implements SaExp{ + + public SaExpLire(){ + } + + public Type getType(){ + return Type.ENTIER; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } +} diff --git a/src/sa/SaExpMult.java b/src/sa/SaExpMult.java new file mode 100644 index 0000000000000000000000000000000000000000..597038dc0fdade0639bdf52e2eb622dbf347055a --- /dev/null +++ b/src/sa/SaExpMult.java @@ -0,0 +1,27 @@ +package sa; +import util.Type; + +public class SaExpMult implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpMult(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.ENTIER; + } + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpNot.java b/src/sa/SaExpNot.java new file mode 100644 index 0000000000000000000000000000000000000000..60a1c08aa6cc3097f205d3f51cb159117946666a --- /dev/null +++ b/src/sa/SaExpNot.java @@ -0,0 +1,26 @@ +package sa; +import util.Type; + +public class SaExpNot implements SaExp{ + private SaExp op1; + + public SaExpNot(SaExp op1){ + this.op1 = op1; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return null;} + + public Type getType(){ + return Type.BOOL; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + ")"; + } +} diff --git a/src/sa/SaExpOr.java b/src/sa/SaExpOr.java new file mode 100644 index 0000000000000000000000000000000000000000..ec9807d3a9f600483df235ebd151d6f356e9dcfb --- /dev/null +++ b/src/sa/SaExpOr.java @@ -0,0 +1,28 @@ +package sa; +import util.Type; + +public class SaExpOr implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpOr(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.BOOL; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpSub.java b/src/sa/SaExpSub.java new file mode 100644 index 0000000000000000000000000000000000000000..bf02733028e29275798694ded4d36faf7591da3c --- /dev/null +++ b/src/sa/SaExpSub.java @@ -0,0 +1,28 @@ +package sa; +import util.Type; + +public class SaExpSub implements SaExp{ + private SaExp op1; + private SaExp op2; + + public SaExpSub(SaExp op1, SaExp op2){ + this.op1 = op1; + this.op2 = op2; + } + + public SaExp getOp1(){return this.op1;} + public SaExp getOp2(){return this.op2;} + + public Type getType(){ + return Type.ENTIER; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + op1 + " " + op2 + ")"; + } +} diff --git a/src/sa/SaExpVar.java b/src/sa/SaExpVar.java new file mode 100644 index 0000000000000000000000000000000000000000..f983c1fdb0e37ee2bf0ab8cd1242f7f596f5023f --- /dev/null +++ b/src/sa/SaExpVar.java @@ -0,0 +1,24 @@ +package sa; +import util.Type; + +public class SaExpVar implements SaExp{ + private SaVar var; + + public SaExpVar(SaVar var){ + this.var = var; + } + + public SaVar getVar(){return this.var;} + + public Type getType(){ + return this.var.getTsItem().getType(); + } + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + var + ")"; + } +} diff --git a/src/sa/SaExpVrai.java b/src/sa/SaExpVrai.java new file mode 100644 index 0000000000000000000000000000000000000000..ef992113637d8e746629cfdb508d8d6e817dfe5f --- /dev/null +++ b/src/sa/SaExpVrai.java @@ -0,0 +1,27 @@ +package sa; +import util.Type; + +public class SaExpVrai implements SaExp{ + private final boolean val; + + public SaExpVrai(){ + this.val = true; + } + + public boolean getVal(){ + return this.val; + } + + public Type getType(){ + return Type.BOOL; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "vrai"; + } +} diff --git a/src/sa/SaInst.java b/src/sa/SaInst.java new file mode 100644 index 0000000000000000000000000000000000000000..409ef53d5f0a324cc3eb7dde5929e1deeeb2f1ef --- /dev/null +++ b/src/sa/SaInst.java @@ -0,0 +1,5 @@ +package sa; + +public interface SaInst extends SaNode { + +} diff --git a/src/sa/SaInstAffect.java b/src/sa/SaInstAffect.java new file mode 100644 index 0000000000000000000000000000000000000000..126f741d3e900f468a368ad089faaf9c18c83e0d --- /dev/null +++ b/src/sa/SaInstAffect.java @@ -0,0 +1,22 @@ +package sa; + +public class SaInstAffect implements SaInst{ + private SaVar lhs; + private SaExp rhs; + + public SaInstAffect(SaVar lhs, SaExp rhs){ + this.lhs = lhs; + this.rhs = rhs; + } + public SaVar getLhs(){return this.lhs;} + public SaExp getRhs(){return this.rhs;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName()+ " " + lhs + " " + rhs + ")"; + } +} diff --git a/src/sa/SaInstBloc.java b/src/sa/SaInstBloc.java new file mode 100644 index 0000000000000000000000000000000000000000..8f13f49c6bccdc48b6fc4bda8cdbe9e8a417ffc1 --- /dev/null +++ b/src/sa/SaInstBloc.java @@ -0,0 +1,19 @@ +package sa; + +public class SaInstBloc implements SaInst{ + private SaLInst val; + + public SaInstBloc(SaLInst val){ + this.val = val; + } + + public SaLInst getVal(){return this.val;} + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + val + ")"; + } +} diff --git a/src/sa/SaInstEcriture.java b/src/sa/SaInstEcriture.java new file mode 100644 index 0000000000000000000000000000000000000000..4ba2af340865b3579f6a28de66f28ce3b8797700 --- /dev/null +++ b/src/sa/SaInstEcriture.java @@ -0,0 +1,20 @@ +package sa; + +public class SaInstEcriture implements SaInst{ + private SaExp arg; + + public SaInstEcriture(SaExp arg){ + this.arg = arg; + } + + public SaExp getArg(){return this.arg;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + arg + ")"; + } +} diff --git a/src/sa/SaInstRetour.java b/src/sa/SaInstRetour.java new file mode 100644 index 0000000000000000000000000000000000000000..c3993e88ee81b9f5584e2a3da6dff5911d50f718 --- /dev/null +++ b/src/sa/SaInstRetour.java @@ -0,0 +1,24 @@ +package sa; +import util.Type; + +public class SaInstRetour implements SaInst{ + private SaExp val; + + public SaInstRetour(SaExp val){ + this.val = val; + } + + public Type getType(){ + return val.getType(); + } + public SaExp getVal(){return this.val;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + val + ")"; + } +} diff --git a/src/sa/SaInstSi.java b/src/sa/SaInstSi.java new file mode 100644 index 0000000000000000000000000000000000000000..fc8c1d7a1c02b1da58a2e8dcaec1d2b9f2b1cd11 --- /dev/null +++ b/src/sa/SaInstSi.java @@ -0,0 +1,26 @@ +package sa; + +public class SaInstSi implements SaInst{ + private SaExp test; + private SaInst alors; + private SaInst sinon; + + public SaInstSi(SaExp test, SaInst alors, SaInst sinon){ + this.test = test; + this.alors = alors; + this.sinon = sinon; + } + + public SaExp getTest(){return this.test;} + public SaInst getAlors(){return this.alors;} + public SaInst getSinon(){return this.sinon;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + test + " " + alors + " " + sinon + ")"; + } +} diff --git a/src/sa/SaInstTantQue.java b/src/sa/SaInstTantQue.java new file mode 100644 index 0000000000000000000000000000000000000000..dfc87e1b053b28b22281134d6dc8756108cf2dff --- /dev/null +++ b/src/sa/SaInstTantQue.java @@ -0,0 +1,23 @@ +package sa; + +public class SaInstTantQue implements SaInst{ + private SaExp test; + private SaInst faire; + + public SaInstTantQue(SaExp test, SaInst faire){ + this.test = test; + this.faire = faire; + } + + public SaExp getTest(){return this.test;} + public SaInst getFaire(){return this.faire;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + test + " " + faire + ")"; + } +} diff --git a/src/sa/SaLDecFonc.java b/src/sa/SaLDecFonc.java new file mode 100644 index 0000000000000000000000000000000000000000..73135aeaf1b30f4684851bd6f0dc90f0f97dbe73 --- /dev/null +++ b/src/sa/SaLDecFonc.java @@ -0,0 +1,28 @@ +package sa; + +public class SaLDecFonc implements SaNode{ + private SaDecFonc tete; + private SaLDecFonc queue; + + public SaLDecFonc(SaDecFonc tete, SaLDecFonc queue){ + this.tete = tete; + this.queue = queue; + } + + public SaDecFonc getTete(){return this.tete;} + public SaLDecFonc getQueue(){return this.queue;} + + public int length(){ + if(this.queue == null) return 1; + return 1 + this.queue.length() ; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue + ")"; + } + +} diff --git a/src/sa/SaLDecVar.java b/src/sa/SaLDecVar.java new file mode 100644 index 0000000000000000000000000000000000000000..9f69dc3ed20db5c58d68cdff7dc21d20a1883d7d --- /dev/null +++ b/src/sa/SaLDecVar.java @@ -0,0 +1,27 @@ +package sa; + +public class SaLDecVar implements SaNode{ + private SaDecVar tete; + private SaLDecVar queue; + + public SaLDecVar(SaDecVar tete, SaLDecVar queue){ + this.tete = tete; + this.queue = queue; + } + + public SaDecVar getTete(){return this.tete;} + public SaLDecVar getQueue(){return this.queue;} + + public int length(){ + if(this.queue == null) return 1; + return 1 + this.queue.length() ; + } + + public <T> T accept(SaVisitor <T> visitor) throws Exception { + return visitor.visit(this); + } + public String toString(){ + return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue + ")"; + } + +} diff --git a/src/sa/SaLExp.java b/src/sa/SaLExp.java new file mode 100644 index 0000000000000000000000000000000000000000..a6e489fd7262d334388bd399ff5e793e5718675f --- /dev/null +++ b/src/sa/SaLExp.java @@ -0,0 +1,30 @@ +package sa; + +public class SaLExp implements SaNode{ + private SaExp tete; + private SaLExp queue; + + public SaLExp(SaExp tete, SaLExp queue){ + this.tete = tete; + this.queue = queue; + } + + public SaExp getTete(){return this.tete;} + public SaLExp getQueue(){return this.queue;} + + public int length(){ + if(this.queue == null) return 1; + return 1 + this.queue.length() ; + } + + + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue + ")"; + } +} diff --git a/src/sa/SaLInst.java b/src/sa/SaLInst.java new file mode 100644 index 0000000000000000000000000000000000000000..29c7cd06d8a6c5a810b0b0750485f7e455ea08ff --- /dev/null +++ b/src/sa/SaLInst.java @@ -0,0 +1,23 @@ +package sa; + +public class SaLInst implements SaNode{ + private SaInst tete; + private SaLInst queue; + + public SaLInst(SaInst tete, SaLInst queue){ + this.tete = tete; + this.queue = queue; + } + + public SaInst getTete(){return this.tete;} + public SaLInst getQueue(){return this.queue;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + public String toString(){ + return "(" + this.getClass().getSimpleName() + " " + tete + " " + queue +")"; + } + +} diff --git a/src/sa/SaNode.java b/src/sa/SaNode.java new file mode 100644 index 0000000000000000000000000000000000000000..cd65a017106d6bc8e3da3cc141677127b2d6a18e --- /dev/null +++ b/src/sa/SaNode.java @@ -0,0 +1,6 @@ +package sa; + +public interface SaNode{ + public <T> T accept(SaVisitor <T> visitor) throws Exception; +} + diff --git a/src/sa/SaProg.java b/src/sa/SaProg.java new file mode 100644 index 0000000000000000000000000000000000000000..f0081db250d89a1d48a676f1f13f987192b056e3 --- /dev/null +++ b/src/sa/SaProg.java @@ -0,0 +1,21 @@ +package sa; + +public class SaProg implements SaNode{ + private SaLDecVar variables; + private SaLDecFonc fonctions; + + public SaProg(SaLDecVar variables, SaLDecFonc fonctions){ + this.variables = variables; + this.fonctions = fonctions; + } + + public SaLDecVar getVariables(){return this.variables;} + public SaLDecFonc getFonctions(){return this.fonctions;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + public String toString(){ + return "(" + this.getClass().getSimpleName() + " " + variables + " " + fonctions +")"; + } +} diff --git a/src/sa/SaTypeCheck.java b/src/sa/SaTypeCheck.java new file mode 100644 index 0000000000000000000000000000000000000000..60e71efec1cba615a2f3bb32f6c710652f1f5086 --- /dev/null +++ b/src/sa/SaTypeCheck.java @@ -0,0 +1,32 @@ +package sa; +import util.Type; +import util.Error; +import ts.*; + +public class SaTypeCheck extends SaDepthFirstVisitor <Void>{ + private TsItemFct fonctionCourante; + + public SaTypeCheck(SaNode root) + { + try{ + root.accept(this); + } catch(ErrorException e){ + System.err.print("ERREUR DE TYPAGE : "); + System.err.println(e.getMessage()); + System.exit(e.getCode()); + } catch(Exception e){} + } + + public void defaultIn(SaNode node) + { + // System.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(SaNode node) + { + // System.out.println("</" + node.getClass().getSimpleName() + ">"); + } + + + +} diff --git a/src/sa/SaVar.java b/src/sa/SaVar.java new file mode 100644 index 0000000000000000000000000000000000000000..8e5536ed3b3374d9272e3a86b79caf0410852638 --- /dev/null +++ b/src/sa/SaVar.java @@ -0,0 +1,6 @@ +package sa; +import ts.*; + +public interface SaVar extends SaNode { + TsItemVar getTsItem(); +} diff --git a/src/sa/SaVarIndicee.java b/src/sa/SaVarIndicee.java new file mode 100644 index 0000000000000000000000000000000000000000..d125b11b4d0488fd44e0fe18b0c340835ff9dbd6 --- /dev/null +++ b/src/sa/SaVarIndicee.java @@ -0,0 +1,27 @@ +package sa; +import ts.*; + +public class SaVarIndicee implements SaVar{ + private String nom; + private SaExp indice; + public TsItemVar tsItem; + + public SaVarIndicee(String nom, SaExp indice){ + this.nom = nom; + this.indice = indice; + this.tsItem = null; + } + + public TsItemVar getTsItem(){return this.tsItem;} + public String getNom(){return this.nom;} + public SaExp getIndice(){return this.indice;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName() + " " + nom + " " + indice +")"; + } +} diff --git a/src/sa/SaVarSimple.java b/src/sa/SaVarSimple.java new file mode 100644 index 0000000000000000000000000000000000000000..d496e74ac0ab58ec1cc908cb8e0fe2331e13976f --- /dev/null +++ b/src/sa/SaVarSimple.java @@ -0,0 +1,24 @@ +package sa; +import ts.*; + +public class SaVarSimple implements SaVar{ + public String nom; + public TsItemVarSimple tsItem; + + public SaVarSimple(String nom){ + this.nom = nom; + this.tsItem = null; + } + + public String getNom(){return this.nom;} + public TsItemVarSimple getTsItem(){return this.tsItem;} + + public <T> T accept(SaVisitor <T> visitor) throws Exception{ + return visitor.visit(this); + } + + @Override + public String toString() { + return "(" + this.getClass().getSimpleName()+ " " + nom + ")"; + } +} diff --git a/src/sa/SaVisitor.java b/src/sa/SaVisitor.java new file mode 100644 index 0000000000000000000000000000000000000000..3d28bb7870f422fa6caa7a50066a819b40fa6c11 --- /dev/null +++ b/src/sa/SaVisitor.java @@ -0,0 +1,38 @@ +package sa; + +interface SaVisitor <T> { + public T visit(SaProg node) throws Exception; + public T visit(SaInstEcriture node) throws Exception; + public T visit(SaInstTantQue node) throws Exception; + public T visit(SaInstBloc node) throws Exception; + public T visit(SaInstSi node) throws Exception; + public T visit(SaInstAffect node) throws Exception; + public T visit(SaInstRetour node) throws Exception; + public T visit(SaLInst node) throws Exception; + public T visit(SaDecFonc node) throws Exception; + public T visit(SaDecVar node) throws Exception; + public T visit(SaDecTab node) throws Exception; + // public T visit(SaLDec node) throws Exception; + public T visit(SaLDecVar node) throws Exception; + public T visit(SaLDecFonc node) throws Exception; + public T visit(SaVarSimple node) throws Exception; + public T visit(SaVarIndicee node) throws Exception; + public T visit(SaAppel node) throws Exception; + public T visit(SaExp node) throws Exception; + public T visit(SaExpLire node) throws Exception; + public T visit(SaExpInt node) throws Exception; + public T visit(SaExpVrai node) throws Exception; + public T visit(SaExpFaux node) throws Exception; + public T visit(SaExpVar node) throws Exception; + public T visit(SaExpAppel node) throws Exception; + public T visit(SaExpAdd node) throws Exception; + public T visit(SaExpSub node) throws Exception; + public T visit(SaExpMult node) throws Exception; + public T visit(SaExpDiv node) throws Exception; + public T visit(SaExpInf node) throws Exception; + public T visit(SaExpEqual node) throws Exception; + public T visit(SaExpAnd node) throws Exception; + public T visit(SaExpOr node) throws Exception; + public T visit(SaExpNot node) throws Exception; + public T visit(SaLExp node) throws Exception; +} diff --git a/src/sa/Sc2sa.java b/src/sa/Sc2sa.java new file mode 100644 index 0000000000000000000000000000000000000000..0bc4abd6ec52633b975ecfb731e2db8b18e8f1e5 --- /dev/null +++ b/src/sa/Sc2sa.java @@ -0,0 +1,43 @@ +package sa; +import lParser.analysis.*; +import lParser.node.*; +import util.Type; + +public class Sc2sa extends DepthFirstAdapter +{ + private SaNode returnValue; + private Type returnType; + private SaProg saRoot = null; + + public void defaultIn(@SuppressWarnings("unused") Node node) + { + //System.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(@SuppressWarnings("unused") Node node) + { + //System.out.println("</" + node.getClass().getSimpleName() + ">"); + } + + public SaProg getRoot() + { + return this.saRoot; + } + + + // exp3 = {plus} exp3 plus exp4 + /* @Override + public void caseAPlusExp3(APlusExp3 node) + { + SaExp op1 = null; + SaExp op2 = null; + inAPlusExp3(node); + node.getExp3().apply(this); + op1 = (SaExp) this.returnValue; + node.getExp4().apply(this); + op2 = (SaExp) this.returnValue; + this.returnValue = new SaExpAdd(op1, op2); + outAPlusExp3(node); + }*/ +} + diff --git a/src/sa/TypeVal.java b/src/sa/TypeVal.java new file mode 100644 index 0000000000000000000000000000000000000000..54cf58ba35f3d0aa29407d82b6b81f1a0f8aab77 --- /dev/null +++ b/src/sa/TypeVal.java @@ -0,0 +1,31 @@ +package sa; +import util.Type; + +public class TypeVal{ + public Type type; + public boolean valBool; + public int valInt; + + public TypeVal(int val) + { + type = Type.ENTIER; + valInt = val; + } + + public TypeVal(boolean val) + { + type = Type.BOOL; + valBool = val; + } + + public String toString(){ + if(type == Type.BOOL){ + return (valBool == true)? String.valueOf(1): String.valueOf(0); + } + else{ + return String.valueOf(valInt); + } + } + + +} diff --git a/src/sc/Sc2Xml.java b/src/sc/Sc2Xml.java new file mode 100644 index 0000000000000000000000000000000000000000..a70781c44459ff2a62334043b223762448126d62 --- /dev/null +++ b/src/sc/Sc2Xml.java @@ -0,0 +1,48 @@ +package sc; +import java.io.*; +import lParser.analysis.*; +import lParser.node.*; + +public class Sc2Xml extends DepthFirstAdapter +{ + private int indentation; + private String baseFileName; + private String fileName; + private PrintStream out; + + public Sc2Xml(String baseFileName) + { + + if (baseFileName == null){ + this.out = System.out; + + } + else{ + try { + this.baseFileName = baseFileName; + this.fileName = baseFileName + ".sc"; + this.out = new PrintStream(this.fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + } + + + public void defaultIn(@SuppressWarnings("unused") Node node) + { + for(int i = 0; i < this.indentation; i++){this.out.print(" ");} + this.indentation++; + this.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(@SuppressWarnings("unused") Node node) + { + this.indentation--; + for(int i = 0; i < this.indentation; i++){this.out.print(" ");} + this.out.println("</" + node.getClass().getSimpleName() + ">"); + } + +} diff --git a/src/ts/Sa2ts.java b/src/ts/Sa2ts.java new file mode 100644 index 0000000000000000000000000000000000000000..50a80a6c17ef87000261b8a1dbf16dd07675709e --- /dev/null +++ b/src/ts/Sa2ts.java @@ -0,0 +1,36 @@ +package ts; +import sa.*; +import util.Error; + +public class Sa2ts extends SaDepthFirstVisitor <Void> { + enum Context { + LOCAL, + GLOBAL, + PARAM + } + + private Ts tableGlobale; + private Ts tableLocaleCourante; + private Context context; + + public Ts getTableGlobale(){return this.tableGlobale;} + + public Sa2ts() + { + tableGlobale = new Ts(); + tableLocaleCourante = null; + context = Context.GLOBAL; + } + + public void defaultIn(SaNode node) + { + // System.out.println("<" + node.getClass().getSimpleName() + ">"); + } + + public void defaultOut(SaNode node) + { + // System.out.println("</" + node.getClass().getSimpleName() + ">"); + } + + +} diff --git a/src/ts/Ts.java b/src/ts/Ts.java new file mode 100644 index 0000000000000000000000000000000000000000..d95fb75ed1196eb28dbdeee9d450bbbe5f847082 --- /dev/null +++ b/src/ts/Ts.java @@ -0,0 +1,147 @@ +package ts; +import java.io.*; +import java.util.*; +import sa.*; +import util.Type; + +public class Ts +{ + public Map< String, TsItemFct> fonctions; + public Map< String, TsItemVar> variables; + private int adrVarCourante; + private int adrArgCourante; + + public int getAdrVarCourante(){return adrVarCourante;} + public int getAdrArgCourante(){return adrArgCourante;} + + public Ts(){ + this.fonctions = new HashMap< String, TsItemFct>(); + this.variables = new HashMap< String, TsItemVar>(); + this.adrVarCourante = 0; + this.adrArgCourante = 0; + } + + public TsItemVar addVar(String identif, Type type) + { + TsItemVar item = new TsItemVarSimple(identif, type); + item.portee = this; + item.adresse = this.adrVarCourante; + item.isParam = false; + this.adrVarCourante += type.taille(); + this.variables.put(identif, item); + return item; + } + + public TsItemVar addParam(String identif, Type type) + { + TsItemVar item = new TsItemVarSimple(identif, type); + item.portee = this; + item.adresse = this.adrArgCourante; + item.isParam = true; + this.adrArgCourante += type.taille(); + this.variables.put(identif, item); + return item; + } + + public TsItemVar addTab(String identif, Type type, int taille) + { + TsItemVar item = new TsItemVarTab(identif, type, taille); + item.portee = this; + item.adresse = this.adrVarCourante; + this.adrVarCourante += taille * type.taille(); + this.variables.put(identif, item); + return item; + } + + public TsItemFct addFct(String identif, Type typeRetour, int nbArgs, Ts table, SaDecFonc saDecFonc) + { + TsItemFct item = new TsItemFct(identif, typeRetour, nbArgs, table, saDecFonc); + this.fonctions.put(identif, item); + return item; + } + + public TsItemVar getVar(String identif) + { + return variables.get(identif); + } + + public TsItemFct getFct(String identif) + { + return fonctions.get(identif); + } + + public Ts getTableLocale(String identif){ + TsItemFct item = this.fonctions.get(identif); + if(item == null) + return null; + else + return item.getTable(); + } + + + public void affiche(PrintStream out){ + ArrayList< Map.Entry< String, TsItemVar> > stVar = new ArrayList<Map.Entry< String, TsItemVar>>(this.variables.entrySet()); + Collections.sort(stVar, new Comparator<Map.Entry< String, TsItemVar>>() { + @Override + public int compare(Map.Entry< String, TsItemVar> entry1, Map.Entry< String, TsItemVar> entry2) + { + return entry1.getKey().compareTo(entry2.getKey()); + } + }); + for (Map.Entry< String, TsItemVar> me:stVar){ + out.println(me.getValue()); + // out.println(me.getKey() + ":\t" + me.getValue()); + } + + ArrayList< Map.Entry< String, TsItemFct> > stFct = new ArrayList<Map.Entry< String, TsItemFct>>(this.fonctions.entrySet()); + Collections.sort(stFct, new Comparator<Map.Entry< String, TsItemFct>>() { + @Override + public int compare(Map.Entry< String, TsItemFct> entry1, Map.Entry< String, TsItemFct> entry2) + { + return entry1.getKey().compareTo(entry2.getKey()); + } + }); + for (Map.Entry< String, TsItemFct> me:stFct){ + out.println(me.getValue()); + // out.println(me.getKey() + ":\t" + me.getValue()); + } + } + + public void afficheTablesLocales(PrintStream out){ + ArrayList< Map.Entry< String, TsItemFct> > st = new ArrayList<Map.Entry< String, TsItemFct>>(this.fonctions.entrySet()); + Collections.sort(st, new Comparator<Map.Entry< String, TsItemFct>>() { + @Override + public int compare(Map.Entry< String, TsItemFct> entry1, Map.Entry< String, TsItemFct> entry2) + { + return entry1.getKey().compareTo(entry2.getKey()); + } + }); + for (Map.Entry< String, TsItemFct> me:st){ + if(me.getValue().getTable() != null){ + out.println("TABLE LOCALE : " + me.getKey()); + me.getValue().getTable().affiche(out); + } + } + } + + public void afficheTout(String baseFileName){ + String fileName; + PrintStream out = System.out; + + if (baseFileName != null){ + try { + baseFileName = baseFileName; + fileName = baseFileName + ".ts"; + out = new PrintStream(fileName); + } + + catch (IOException e) { + System.err.println("Error: " + e.getMessage()); + } + } + out.println("TABLE GLOBALE"); + this.affiche(out); + this.afficheTablesLocales(out); + } + +} diff --git a/src/ts/TsItemFct.java b/src/ts/TsItemFct.java new file mode 100644 index 0000000000000000000000000000000000000000..03e87f65dda8622fe8f5de40416054f2ca1d00a8 --- /dev/null +++ b/src/ts/TsItemFct.java @@ -0,0 +1,30 @@ +package ts; +import sa.*; +import util.Type; + + +public class TsItemFct { + public String identif; + public int nbArgs; + public Ts table; + public SaDecFonc saDecFonc; + public Type typeRetour; + + public TsItemFct(String identif, Type typeRetour, int nbArgs, Ts table, SaDecFonc saDecFonc){ + this.identif = identif; + this.nbArgs = nbArgs; + this.table = table; + this.saDecFonc = saDecFonc; + this.typeRetour = typeRetour; + } + + public int getNbArgs(){return this.nbArgs;} + public Ts getTable(){return this.table;} + public Type getTypeRetour(){return this.typeRetour;} + public String getIdentif(){return this.identif;} + public String toString(){ + return this.identif + "\tFCT\t" + typeRetour + "\t" + this.nbArgs; + } + +} + diff --git a/src/ts/TsItemVar.java b/src/ts/TsItemVar.java new file mode 100644 index 0000000000000000000000000000000000000000..7dae2bb896d63d316875f99ff8a3a45023110c49 --- /dev/null +++ b/src/ts/TsItemVar.java @@ -0,0 +1,20 @@ +package ts; +import util.Type; + +public abstract class TsItemVar { + public Ts portee; + public int adresse; + public String identif; + public int taille; + public boolean isParam; + public Type type; + + public int getAdresse(){return this.adresse;} + public String getIdentif(){return this.identif;} + public Ts getPortee() {return this.portee;} + public Type getType() {return this.type;} + public int getTaille(){return this.taille;} + + +} + diff --git a/src/ts/TsItemVarSimple.java b/src/ts/TsItemVarSimple.java new file mode 100644 index 0000000000000000000000000000000000000000..ae2a555a1149f34755bfb7a4ae4dde02a5345309 --- /dev/null +++ b/src/ts/TsItemVarSimple.java @@ -0,0 +1,22 @@ +package ts; +import util.Type; + +public class TsItemVarSimple extends TsItemVar{ + public TsItemVarSimple(String identif, Type type){ + this.identif = identif; + this.adresse = 0; + this.portee = null; + this.taille = 1; + this.isParam = false; + this.type = type; + } + + public String toString(){ + if(this.isParam) + return this.identif + "\tPARAM\t" + this.type + "\t" + this.adresse; + else + return this.identif + "\tVAR \t" + this.type + "\t" + this.adresse; + } + +} + diff --git a/src/ts/TsItemVarTab.java b/src/ts/TsItemVarTab.java new file mode 100644 index 0000000000000000000000000000000000000000..56c0a116605fb11714826d27714c2aa3b046cc5c --- /dev/null +++ b/src/ts/TsItemVarTab.java @@ -0,0 +1,19 @@ +package ts; +import util.Type; + +public class TsItemVarTab extends TsItemVar{ + public TsItemVarTab(String identif, Type type, int taille){ + this.identif = identif; + this.adresse = 0; + this.portee = null; + this.taille = taille; + this.isParam = false; + this.type = type; + } + + public String toString(){ + return this.identif + "\tTAB \t" + this.type + "\t" + this.adresse + "\t" + this.taille; + } + +} + diff --git a/src/ts/TsParser.java b/src/ts/TsParser.java new file mode 100644 index 0000000000000000000000000000000000000000..509bff6ee29d53d5f75a8d3928b1c0eb8277ac2a --- /dev/null +++ b/src/ts/TsParser.java @@ -0,0 +1,71 @@ +package ts; + +import ts.Ts; + +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import util.Type; + +public class TsParser { + private Ts tableCourante = null; + private Ts tableGlobale = null; + + public TsParser(){ + + } + + public Ts parse(String filePath){ + try { + Files.lines(Paths.get(filePath)).forEachOrdered(this::processLine);; + } catch(IOException e){ + e.printStackTrace(); + } + return tableGlobale; + } + + private void processLine(String line){ +// System.out.println(line); + var tokens = line.split("([ ]|[\t])+"); + if(tokens[1].equals("GLOBALE")){ + tableGlobale = new Ts(); + tableCourante = tableGlobale; + return; + } + if(tokens[1].equals("LOCALE")){ + tableCourante = tableGlobale.getFct(tokens[3]).getTable(); + return; + } + if(tokens[1].equals("VAR")){ + tableCourante.addVar(tokens[0], Type.fromString(tokens[2])); + return; + } + if(tokens[1].equals("PARAM")){ + tableCourante.addParam(tokens[0], Type.fromString(tokens[2])); + return; + } + if(tokens[1].equals("TAB")){ + tableCourante.addTab(tokens[0], Type.fromString(tokens[2]), Integer.parseInt(tokens[4])); + return; + } + if(tokens[1].equals("FCT")){ + tableGlobale.addFct(tokens[0], Type.fromString(tokens[2]), Integer.parseInt(tokens[3]), new Ts(), null); + return; + } + } + /* + public static void main(String args[]){ + var parser = new SymbolsTableParser(); + var r = parser.parse("function.ts"); + System.out.println("---Table Globale---"); + r.affiche(System.out); + System.out.println("---Tables Locales---"); + r.afficheTablesLocales(System.out); + }*/ +} diff --git a/src/util/Error.java b/src/util/Error.java new file mode 100644 index 0000000000000000000000000000000000000000..4a7500040e46a9e9d914f8865cb653da75a2c073 --- /dev/null +++ b/src/util/Error.java @@ -0,0 +1,21 @@ +package util; + +public enum Error{ + NOERROR(0, "sortie normale"), + TYPE(3, "erreur de types"), + TS(4, "table des symboles"), + SYNT(5,"erreur de syntaxe"), + LEX(6, "lexical error"); + + private final String message; + private final int code; + + Error(int code, String message){ + this.code = code; + this.message = message; + } + + public String toString(){return message;} + public String message(){return message;} + public int code(){return code;} +} diff --git a/src/util/Memory.java b/src/util/Memory.java new file mode 100644 index 0000000000000000000000000000000000000000..688a9da4134d2c2fcb46c61bedbeda7d4d5ebe70 --- /dev/null +++ b/src/util/Memory.java @@ -0,0 +1,224 @@ +package util; + +/* Big Endian */ + +public class Memory{ + /* stack segment */ + private int ss; + + /* data segment */ + private int ds; + + public int esp; // adresse du sommet de la pile en octets + private int memSize; + private int dataSize; + private int stackSize; + private byte[] mem; + + public Memory(int dataSize, int stackSize){ + this.dataSize = dataSize; + this.stackSize = stackSize; + this.memSize = dataSize + stackSize; + mem = new byte[memSize]; + ss = memSize - 1; + esp = ss; + ds = 0; + } + + public void printStack(){ + for(int adr = ss - 3; adr > esp; adr = adr - 4){ + System.out.print(readInt(adr) + "\t"); + } + System.out.println(); + } + + public int readInt(int address){ + if((address < 0) || (address + 3 > ss)) + throw new RuntimeException("segmentation fault"); + return bytesToInt(mem[address], mem[address + 1], mem[address + 2], mem[address + 3]); + } + + + public boolean readBoolean(int address){ + if((address < 0) || (address > ss)) + throw new RuntimeException("segmentation fault"); + return byteToBoolean(mem[address]); + } + + public byte readByte(int address){ + if((address < 0) || (address > ss)) + throw new RuntimeException("segmentation fault"); + return mem[address]; + } + + public void writeInt(int address, int value){ + if((address < 0) || (address + 3 > ss)) + throw new RuntimeException("segmentation fault"); + + byte[] fourBytes = intToBytes(value); + mem[address] = fourBytes[0]; + mem[address + 1] = fourBytes[1]; + mem[address + 2] = fourBytes[2]; + mem[address + 3] = fourBytes[3]; + } + + public void writeToMemory(int address, int value){ + if((address < 0) || (address + 3 > ss)) + throw new RuntimeException("segmentation fault"); + + byte[] fourBytes = intToBytes(value); + mem[address] = fourBytes[0]; + mem[address + 1] = fourBytes[1]; + mem[address + 2] = fourBytes[2]; + mem[address + 3] = fourBytes[3]; + } + + /* public void writeToMemory(int address, boolean value) + { + if((address < 0) || (address > ss)) + throw new RuntimeException("segmentation fault"); + mem[address] = booleanToByte(value); + }*/ + + + /* revoir c'est quoi cette affaire */ + public int readNBytes(int address, int n){ + // System.out.println("read memory at address " + address); + if((address < 0) || (address + n - 1 > ss)) + throw new RuntimeException("segmentation fault"); + if(n == 1) + return (int)mem[address]; + // if(n == 4) revoir pourquoi c'est commenté !! + return bytesToInt(mem[address], mem[address + 1], mem[address + 2], mem[address + 3]); + + } + + /* public void writeNBytes(int address, int value){ + if((address < 0) || (address + n - 1 > ss)) + throw new RuntimeException("segmentation fault"); + + byte[] fourBytes = intToBytes(value); + mem[address] = fourBytes[0]; + mem[address + 1] = fourBytes[1]; + mem[address + 2] = fourBytes[2]; + mem[address + 3] = fourBytes[3]; + }*/ + + + + public void writeBoolean(int address, boolean value) + { + if((address < 0) || (address > ss)) + throw new RuntimeException("segmentation fault"); + mem[address] = booleanToByte(value); + } + + public void pushInt(int value){ + if(esp - 3 < dataSize) + throw new RuntimeException("stack overflow"); + + byte[] fourBytes = intToBytes(value); + mem[--esp] = fourBytes[3]; + mem[--esp] = fourBytes[2]; + mem[--esp] = fourBytes[1]; + mem[--esp] = fourBytes[0]; + + + } + /* + public void pushBoolean(boolean value){ + if(esp == dataSize) + throw new RuntimeException("stack overflow"); + mem[esp] = booleanToByte(value); + esp--; + + }*/ + + public int getTopInt(){ + // if(esp == ss) + // throw new RuntimeException("empty stack"); + byte byte0 = mem[esp]; + byte byte1 = mem[esp-1]; + byte byte2 = mem[esp-2]; + byte byte3 = mem[esp-3]; + return bytesToInt(byte0, byte1, byte2, byte3); + } + + public int popInt(){ + if(esp + 3 >= ss) + throw new RuntimeException("stack underflow"); + byte byte0 = mem[esp++]; + byte byte1 = mem[esp++]; + byte byte2 = mem[esp++]; + byte byte3 = mem[esp++]; + + return bytesToInt(byte0, byte1, byte2, byte3); + } + + /* public boolean popBoolean() + { + if(esp == ss) + throw new RuntimeException("stack underflow"); + byte byte0 = mem[esp]; + esp++; + return byteToBoolean(byte0); + }*/ + + public int bytesToInt(byte byte0, byte byte1, byte byte2, byte byte3){ + return ((byte0 & 0xFF) << 24) | + ((byte1 & 0xFF) << 16) | + ((byte2 & 0xFF) << 8) | + ((byte3 & 0xFF) << 0); + } + + public byte[] intToBytes2( int data ) { + byte[] result = new byte[4]; + result[0] = (byte) ((data & 0xFF000000) >> 24); + result[1] = (byte) ((data & 0x00FF0000) >> 16); + result[2] = (byte) ((data & 0x0000FF00) >> 8); + result[3] = (byte) ((data & 0x000000FF) >> 0); + return result; +} + public byte[] intToBytes(int i) + { + byte[] result = new byte[4]; + + result[0] = (byte) (i >> 24); + result[1] = (byte) (i >> 16); + result[2] = (byte) (i >> 8); + result[3] = (byte) (i /*>> 0*/); + + return result; + } + + public byte booleanToByte(boolean value) + { + return (value == true)? (byte) 1 : (byte) 0; + } + + public boolean byteToBoolean(byte value) + { + return (value == 1)? true : false; + } + + + /* public static void main(String[] args){ + Memory mem = new Memory(100, 100); + mem.pushInt(3467); + int v = mem.popInt(); + System.out.println("val =" + v); + mem.pushInt(3468); + v = mem.popInt(); + System.out.println("val =" + v); + + mem.writeInt(96, 234); + int val = mem.readInt(96); + System.out.println("val =" + val); + + mem.writeInt(150, 23); + val = mem.readInt(250); + System.out.println("val =" + val); + + }*/ + +} diff --git a/src/util/Type.java b/src/util/Type.java new file mode 100644 index 0000000000000000000000000000000000000000..89e5574b53f8b046e757117b7de79748f18dc8fa --- /dev/null +++ b/src/util/Type.java @@ -0,0 +1,30 @@ +package util; + +public enum Type{ + NUL("nul", 0), + ENTIER("entier", 4), + BOOL("bool", 1); + + private final String nom; + private final int taille; // taille en octets + + Type(String nom, int taille){ + this.nom = nom; + this.taille = taille; + } + + public String toString(){return nom;} + public static Type fromString(String nom){ + if(nom.equals("entier")){return Type.ENTIER;} + if(nom.equals("ENTIER")){return Type.ENTIER;} + if(nom.equals("bool")){return Type.BOOL;} + if(nom.equals("BOOL")){return Type.BOOL;} + if(nom.equals("nul")){return Type.NUL;} + if(nom.equals("NUL")){return Type.NUL;} + return null; + } + + public String nom(){return nom;} + public int taille(){return taille;} + public static boolean checkCompatibility(Type t1, Type t2){return t1 == t2;} +} diff --git a/src/util/graph/ColorGraph.java b/src/util/graph/ColorGraph.java new file mode 100644 index 0000000000000000000000000000000000000000..55b867e821c8182073a421475d2ab4cb875c7215 --- /dev/null +++ b/src/util/graph/ColorGraph.java @@ -0,0 +1,38 @@ +package util.graph; + +import util.graph.*; +import util.intset.*; +import java.util.*; +import java.io.*; + +public class ColorGraph { + public Graph graph; + public int vertexNb; + private Stack<Integer> stack; + public IntSet removed; + public IntSet spill; + public int[] color; + public int colorNb; + public Node[] int2Node; + static int NOCOLOR = -1; + + public ColorGraph(Graph graph, int colorNb, int[] preColoredVertices){ + this.graph = graph; + this.colorNb = colorNb; + stack = new Stack<Integer>(); + vertexNb = graph.nodeCount(); + color = new int[vertexNb]; + removed = new IntSet(vertexNb); + spill = new IntSet(vertexNb); + int2Node = graph.nodeArray(); + for(int v=0; v < vertexNb; v++){ + int preColor = preColoredVertices[v]; + if(preColor >= 0 && preColor < colorNb) + color[v] = preColoredVertices[v]; + else + color[v] = NOCOLOR; + } + } + + +} diff --git a/src/util/graph/Graph.java b/src/util/graph/Graph.java new file mode 100644 index 0000000000000000000000000000000000000000..d62bdb03239d03dc193694bfdfa32dc2063f4ef5 --- /dev/null +++ b/src/util/graph/Graph.java @@ -0,0 +1,83 @@ +package util.graph; + +public class Graph { + + int nodecount=0; + NodeList mynodes, mylast; + public NodeList nodes() { return mynodes;} + + public Node newNode() { + return new Node(this); + } + + void check(Node n) { + if (n.mygraph != this) + throw new Error("Graph.addEdge using nodes from the wrong graph"); + } + + public int nodeCount(){ + return nodecount; + } + + static boolean inList(Node a, NodeList l) { + for(NodeList p=l; p!=null; p=p.tail) + if (p.head==a) return true; + return false; + } + + public Node[] nodeArray(){ + Node[] array = new Node[nodecount]; + for(NodeList q=mynodes; q!=null; q=q.tail) { + array[q.head.mykey] = q.head; + } + return array; + } + + + public void addNOEdge(Node from, Node to) { + check(from); check(to); + if (! from.goesTo(to)){ + to.preds=new NodeList(from, to.preds); + from.succs=new NodeList(to, from.succs); + } + if (! to.goesTo(from)){ + from.preds=new NodeList(to, from.preds); + to.succs=new NodeList(from, to.succs); + } + } + + public void addEdge(Node from, Node to) { + check(from); check(to); + if (from.goesTo(to)) return; + to.preds=new NodeList(from, to.preds); + from.succs=new NodeList(to, from.succs); + } + + NodeList delete(Node a, NodeList l) { + if (l==null) throw new Error("Graph.rmEdge: edge nonexistent"); + else if (a==l.head) return l.tail; + else return new NodeList(l.head, delete(a, l.tail)); + } + + public void rmEdge(Node from, Node to) { + to.preds=delete(from,to.preds); + from.succs=delete(to,from.succs); + } + + /** + * Print a human-readable dump for debugging. + */ + public void show(java.io.PrintStream out) { + for (NodeList p=nodes(); p!=null; p=p.tail) { + Node n = p.head; + out.print(n.toString()); + out.print(": "); + for(NodeList q=n.succ(); q!=null; q=q.tail) { + out.print(q.head.toString()); + out.print(" "); + } + out.println(); + } + } + +} diff --git a/src/util/graph/Node.java b/src/util/graph/Node.java new file mode 100644 index 0000000000000000000000000000000000000000..040f118b159b0597e67970eb81bd07552314307f --- /dev/null +++ b/src/util/graph/Node.java @@ -0,0 +1,55 @@ +package util.graph; + +public class Node { + Graph mygraph; + int mykey; + NodeList succs; + NodeList preds; + + private Node(){} + public Node(Graph g) { + mygraph=g; + mykey= g.nodecount++; + NodeList p = new NodeList(this, null); + if (g.mylast==null) + g.mynodes=g.mylast=p; + else g.mylast = g.mylast.tail = p; + } + + public NodeList succ() {return succs;} + public NodeList pred() {return preds;} + + public int label() {return mykey;} + + + NodeList cat(NodeList a, NodeList b) { + if (a==null) return b; + else return new NodeList(a.head, cat(a.tail,b)); + } + public NodeList adj() {return cat(succ(), pred());} + + int len(NodeList l) { + int i=0; + for(NodeList p=l; p!=null; p=p.tail) i++; + return i; + } + + public int inDegree() {return len(pred());} + public int outDegree() {return len(succ());} + public int degree() {return inDegree()+outDegree();} + + public boolean goesTo(Node n) { + return Graph.inList(n, succ()); + } + + public boolean comesFrom(Node n) { + return Graph.inList(n, pred()); + } + + public boolean adj(Node n) { + return goesTo(n) || comesFrom(n); + } + + public String toString() {return String.valueOf(mykey);} + +} diff --git a/src/util/graph/NodeList.java b/src/util/graph/NodeList.java new file mode 100644 index 0000000000000000000000000000000000000000..4493b7f27149154611026a78dd254d0a56b9a9ef --- /dev/null +++ b/src/util/graph/NodeList.java @@ -0,0 +1,10 @@ +package util.graph; + +public class NodeList { + public Node head; + public NodeList tail; + public NodeList(Node h, NodeList t) {head=h; tail=t;} +} + + + diff --git a/src/util/graph/TestColorGraph.java b/src/util/graph/TestColorGraph.java new file mode 100644 index 0000000000000000000000000000000000000000..c496fae04a3ceed14608d5c57fd441662c7ead1c --- /dev/null +++ b/src/util/graph/TestColorGraph.java @@ -0,0 +1,77 @@ +package util.graph; +import util.graph.*; +import util.intset.*; +import java.util.*; +import java.io.*; + +public class TestColorGraph +{ + public static void main(String[] args) + { + Graph g = new Graph(); + /* + Node n0 = g.newNode(); + Node n1 = g.newNode(); + Node n2 = g.newNode(); + Node n3 = g.newNode(); + Node n4 = g.newNode(); + + g.addNOEdge(n0, n1); + g.addNOEdge(n0, n2); + g.addNOEdge(n0, n3); + g.addNOEdge(n0, n4); + + g.addNOEdge(n1, n2); + g.addNOEdge(n1, n3); + g.addNOEdge(n1, n4); + + g.addNOEdge(n2, n3); + g.addNOEdge(n2, n4); + + g.addNOEdge(n3, n4); + */ + + + Node n1 = g.newNode(); + Node n2 = g.newNode(); + Node n3 = g.newNode(); + Node n4 = g.newNode(); + Node n5 = g.newNode(); + Node n6 = g.newNode(); + Node n7 = g.newNode(); + Node n8 = g.newNode(); + Node n9 = g.newNode(); + Node n10 = g.newNode(); + + g.addNOEdge(n1, n2); + g.addNOEdge(n1, n4); + g.addNOEdge(n1, n9); + + g.addNOEdge(n2, n10); + + g.addNOEdge(n3, n8); + g.addNOEdge(n3, n9); + g.addNOEdge(n3, n10); + + g.addNOEdge(n4, n5); + g.addNOEdge(n4, n8); + g.addNOEdge(n4, n10); + + g.addNOEdge(n5, n8); + g.addNOEdge(n5, n10); + + g.addNOEdge(n6, n7); + g.addNOEdge(n6, n8); + g.addNOEdge(n6, n9); + + g.addNOEdge(n7, n8); + + g.addNOEdge(n8, n9); + + g.show(System.out); + int[] colors = new int[]{ -3,-3,-3,0,-3,2,1,-3,-3,-3}; + ColorGraph cg = new ColorGraph(g, 3, colors); + cg.color(); + cg.affiche(); + } +} diff --git a/src/util/intset/IntSet.java b/src/util/intset/IntSet.java new file mode 100644 index 0000000000000000000000000000000000000000..3d0d5f4153b2481250d3bbd514415be7aa4fabc0 --- /dev/null +++ b/src/util/intset/IntSet.java @@ -0,0 +1,94 @@ +package util.intset; + +public class IntSet{ + private int size; + private boolean array[]; + + public IntSet(int size){ + this.size = size; + array = new boolean[size]; + for (int i = 0; i < size; i++) + array[i] = false; + } + + public int getSize(){ + return size; + } + + public void empty(){ + for (int i = 0; i < size; i++) + array[i] = false; + } + + public boolean isMember(int elt){ + if(elt >= size) return false; + return array[elt]; + } + + public boolean isEmpty(){ + for (int i = 0; i < size; i++) + if(array[i] == true) + return false; + return true; + } + + + public void add(int elt){ + if(elt >= size){ + System.err.println("ERROR : set is too small !!!!"); + } + array[elt] = true; + } + + public void remove(int elt){ + if(elt >= size){ + System.err.println("ERROR : set is too small !!!!"); + } + array[elt] = false; + } + + public IntSet minus(IntSet s){ + for (int i = 0; i < s.size; i++) + if(s.array[i]) + array[i] = false; + return this; + } + + public IntSet copy(){ + IntSet c = new IntSet(size); + for (int i = 0; i < size; i++) + c.array[i] = array[i]; + return c; + } + + public IntSet inter(IntSet s){ + for (int i = 0; i < s.size; i++) + array[i] = array[i] && s.array[i]; + return this; + } + + public IntSet union(IntSet s){ + for (int i = 0; i < s.size; i++) + array[i] = array[i] || s.array[i]; + return this; + } + + public boolean equal(IntSet s){ + for (int i = 0; i < s.size; i++) + if(array[i] != s.array[i]) + return false; + return true; + } + + public String toString(){ + String s = "("; + for (int i = 0; i < size; i++) + if(array[i] == true){ + s += i; + s += " "; + } + s+= ")"; + return s; + } + +} diff --git a/test/c3a-ref/add1.c3a b/test/c3a-ref/add1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..380ea2af6cfd2140bcb1faf76118f1fd83505efd --- /dev/null +++ b/test/c3a-ref/add1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 3 + 10 + write @1 + fend diff --git a/test/c3a-ref/add2.c3a b/test/c3a-ref/add2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..0b62ecfb4cf9cc53109d8335316e6c290188e7a4 --- /dev/null +++ b/test/c3a-ref/add2.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 2 + 4 + @2 = @1 + 8 + write @2 + fend diff --git a/test/c3a-ref/affect1.c3a b/test/c3a-ref/affect1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..6745f487ef8dd4fc2ae9ec137ef147540bce391e --- /dev/null +++ b/test/c3a-ref/affect1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + a = 1 + write a + fend diff --git a/test/c3a-ref/affect2.c3a b/test/c3a-ref/affect2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..6745f487ef8dd4fc2ae9ec137ef147540bce391e --- /dev/null +++ b/test/c3a-ref/affect2.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + a = 1 + write a + fend diff --git a/test/c3a-ref/affect3.c3a b/test/c3a-ref/affect3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..5b21472acf8c0424e83ad9843285fa9eef742642 --- /dev/null +++ b/test/c3a-ref/affect3.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + a = 1 + write a + fend +main fbegin #entree fonction + param 3 + @1 = call f + fend diff --git a/test/c3a-ref/and1.c3a b/test/c3a-ref/and1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..6b1e7f61f7453140e64797fc0acb79614727dcd1 --- /dev/null +++ b/test/c3a-ref/and1.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 == 0 goto 1 + if 1 == 0 goto 1 + @1 = 1 + goto 0 +1 @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/and2.c3a b/test/c3a-ref/and2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..86ec350dd5b6094683e1513a5170d6965565fd52 --- /dev/null +++ b/test/c3a-ref/and2.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 == 0 goto 1 + if 0 == 0 goto 1 + @1 = 1 + goto 0 +1 @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/and3.c3a b/test/c3a-ref/and3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..64950680bd3f32360e1b7782326e57ebe6226492 --- /dev/null +++ b/test/c3a-ref/and3.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 == 0 goto 1 + if 1 == 0 goto 1 + @1 = 1 + goto 0 +1 @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/and4.c3a b/test/c3a-ref/and4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..e86a09092ade8e08d14f707e40018545af1650e9 --- /dev/null +++ b/test/c3a-ref/and4.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 == 0 goto 1 + if 0 == 0 goto 1 + @1 = 1 + goto 0 +1 @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/and5.c3a b/test/c3a-ref/and5.c3a new file mode 100644 index 0000000000000000000000000000000000000000..df33a00f4e2c4836eaf3b214a342a3cff277f676 --- /dev/null +++ b/test/c3a-ref/and5.c3a @@ -0,0 +1,15 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 == 0 goto 3 + if 0 == 0 goto 3 + @2 = 1 + goto 2 +3 @2 = 0 +2 if @2 == 0 goto 1 + if 1 == 0 goto 1 + @1 = 1 + goto 0 +1 @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/appel-param1.c3a b/test/c3a-ref/appel-param1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..f7a67d8d470c20147b647b12c221e4fc7cc5bd50 --- /dev/null +++ b/test/c3a-ref/appel-param1.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + write a + fend +main fbegin #entree fonction + param 1 + @1 = call f + fend diff --git a/test/c3a-ref/appel-param2.c3a b/test/c3a-ref/appel-param2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..280c4b9d9df121d436b8be92c38a089bfe58d806 --- /dev/null +++ b/test/c3a-ref/appel-param2.c3a @@ -0,0 +1,11 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + write a + write b + fend +main fbegin #entree fonction + param 1 + param 456 + @1 = call f + fend diff --git a/test/c3a-ref/appel-param3.c3a b/test/c3a-ref/appel-param3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..68a53cf5537d53566d0ca67008c85c5033ff35d4 --- /dev/null +++ b/test/c3a-ref/appel-param3.c3a @@ -0,0 +1,17 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + write a + write b + write c + write d + write e + fend +main fbegin #entree fonction + param 1 + param 2 + param 3 + param 4 + param 5 + @1 = call f + fend diff --git a/test/c3a-ref/appel-retour1.c3a b/test/c3a-ref/appel-retour1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..7aac5eae2b3cf0dc62c20c43e249d9b516607398 --- /dev/null +++ b/test/c3a-ref/appel-retour1.c3a @@ -0,0 +1,11 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + ret a + fend + fend +main fbegin #entree fonction + param 3712 + @1 = call f + write @1 + fend diff --git a/test/c3a-ref/appel1.c3a b/test/c3a-ref/appel1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..1b31ff0b2403ec593d5a8ace79d3124a15f8c7f4 --- /dev/null +++ b/test/c3a-ref/appel1.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + write 1 + fend +main fbegin #entree fonction + @1 = call f + fend diff --git a/test/c3a-ref/appel2.c3a b/test/c3a-ref/appel2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..5431ed3d565fada7576b75ceb75ae3145898234f --- /dev/null +++ b/test/c3a-ref/appel2.c3a @@ -0,0 +1,12 @@ + @0 = call main + stop @0 +g fbegin #entree fonction + write 2 + fend +f fbegin #entree fonction + write 1 + @1 = call g + fend +main fbegin #entree fonction + @2 = call f + fend diff --git a/test/c3a-ref/appel3.c3a b/test/c3a-ref/appel3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..cf066d8aa5e1c75ac6b84b28a5c9cb9cc6fa1b08 --- /dev/null +++ b/test/c3a-ref/appel3.c3a @@ -0,0 +1,12 @@ + @0 = call main + stop @0 +g fbegin #entree fonction + write 2 + fend +f fbegin #entree fonction + write 1 + fend +main fbegin #entree fonction + @1 = call f + @2 = call g + fend diff --git a/test/c3a-ref/div1.c3a b/test/c3a-ref/div1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..240d4f4c5b11b570aab181dac9b71d27e55d01dd --- /dev/null +++ b/test/c3a-ref/div1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 4 / 2 + write @1 + fend diff --git a/test/c3a-ref/div2.c3a b/test/c3a-ref/div2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..64c4af57d97184402bf0e3dd9f4a86827b29d78a --- /dev/null +++ b/test/c3a-ref/div2.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 0 / 712 + write @1 + fend diff --git a/test/c3a-ref/div3.c3a b/test/c3a-ref/div3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..9275013eea5ce1f296c44219530dd361ada22660 --- /dev/null +++ b/test/c3a-ref/div3.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 4 / 2 + @2 = @1 / 2 + write @2 + fend diff --git a/test/c3a-ref/div4.c3a b/test/c3a-ref/div4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..37d4c267d7436397eb0d22d056d94e3b158e55eb --- /dev/null +++ b/test/c3a-ref/div4.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 2 / 3 + write @1 + fend diff --git a/test/c3a-ref/ecrire1.c3a b/test/c3a-ref/ecrire1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..fa9b045a3e31ad37594e80b7dc6a598762bf6be0 --- /dev/null +++ b/test/c3a-ref/ecrire1.c3a @@ -0,0 +1,5 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + write 3456 + fend diff --git a/test/c3a-ref/ecrire2.c3a b/test/c3a-ref/ecrire2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..bab122306b675cd34e1260e9b610196adddb4d77 --- /dev/null +++ b/test/c3a-ref/ecrire2.c3a @@ -0,0 +1,5 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + write 0 + fend diff --git a/test/c3a-ref/egal1.c3a b/test/c3a-ref/egal1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..8284ba64809b1c7e35b7be49177ab5bee7a50e3e --- /dev/null +++ b/test/c3a-ref/egal1.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 1 + if 123 == 123 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/egal2.c3a b/test/c3a-ref/egal2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..13efbcddb9086f97a2df4630d080310327f8b494 --- /dev/null +++ b/test/c3a-ref/egal2.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 1 + if 412 == 34 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/egal3.c3a b/test/c3a-ref/egal3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..e17359701865d885c36d22442ac2cc07c0b6466e --- /dev/null +++ b/test/c3a-ref/egal3.c3a @@ -0,0 +1,11 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 1 + if 2 == 2 goto 1 + @2 = 0 +1 @1 = 1 + if @2 == 1 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/err5.c3a b/test/c3a-ref/err5.c3a new file mode 100644 index 0000000000000000000000000000000000000000..4f8b67f8dfb78a87aef134850bbe13e5822a22e8 --- /dev/null +++ b/test/c3a-ref/err5.c3a @@ -0,0 +1,7 @@ +f fbegin #entree fonction + write 1 + fend +main fbegin #entree fonction + t0 = call f + f = t0 + fend diff --git a/test/c3a-ref/fibo.c3a b/test/c3a-ref/fibo.c3a new file mode 100644 index 0000000000000000000000000000000000000000..a67a5259d751fa02376cc809d14a249698da7adc --- /dev/null +++ b/test/c3a-ref/fibo.c3a @@ -0,0 +1,25 @@ + @0 = call main + stop @0 +fibo fbegin #entree fonction + @1 = 1 + if n < 2 goto 2 + @1 = 0 +2 if @1 == 0 goto 0 + ret 1 + fend + goto 1 +0 @3 = n - 1 + param @3 + @2 = call fibo + @5 = n - 2 + param @5 + @4 = call fibo + @6 = @2 + @4 + ret @6 + fend +1 fend +main fbegin #entree fonction + param 9 + @7 = call fibo + write @7 + fend diff --git a/test/c3a-ref/inf1.c3a b/test/c3a-ref/inf1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..2d1a31310a7e2afddb23f995fbba8c913a9a4036 --- /dev/null +++ b/test/c3a-ref/inf1.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 1 + if 3 < 3 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/inf2.c3a b/test/c3a-ref/inf2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..de2ab0f59d08a318e6322e9e6230b2f13c592896 --- /dev/null +++ b/test/c3a-ref/inf2.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 1 + if 4 < 1 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/inf3.c3a b/test/c3a-ref/inf3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..83499a0caaab4dd86e77593a26acf228ea9e7d36 --- /dev/null +++ b/test/c3a-ref/inf3.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 1 + if 312 < 475 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/inf4.c3a b/test/c3a-ref/inf4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..98e7d238d171f15c9ea9dc6d30fa3132b2478db6 --- /dev/null +++ b/test/c3a-ref/inf4.c3a @@ -0,0 +1,11 @@ + t0 = call main + stop t0 +main fbegin #entree fonction + t2 = 1 + if 3 < 2 goto l1 + t2 = 0 +l1 t1 = 1 + if t2 < 1 goto l0 + t1 = 0 +l0 write t1 + fend diff --git a/test/c3a-ref/mult1.c3a b/test/c3a-ref/mult1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..34d20ee1c8fb848656ab00644d72aae42435f04a --- /dev/null +++ b/test/c3a-ref/mult1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 2 * 3 + write @1 + fend diff --git a/test/c3a-ref/mult2.c3a b/test/c3a-ref/mult2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..78089fe057148b93ca78fd3bb565bf09fea3f70c --- /dev/null +++ b/test/c3a-ref/mult2.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 0 * 321 + write @1 + fend diff --git a/test/c3a-ref/mult3.c3a b/test/c3a-ref/mult3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..b28dfa91f5b5bad837e5d5a788a1546123cfc9e1 --- /dev/null +++ b/test/c3a-ref/mult3.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 3 * 3 + @2 = @1 * 2 + write @2 + fend diff --git a/test/c3a-ref/not1.c3a b/test/c3a-ref/not1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..991e63eec9769a2956742bafe796c528c0ae10f5 --- /dev/null +++ b/test/c3a-ref/not1.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 1 + if 1 == 0 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/not2.c3a b/test/c3a-ref/not2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..482f3d5844622d223fa8ddbae671866fa9369c1f --- /dev/null +++ b/test/c3a-ref/not2.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 1 + if 0 == 0 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/not3.c3a b/test/c3a-ref/not3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..c0800ee00493c9539abb93ea542db6cc67eb5712 --- /dev/null +++ b/test/c3a-ref/not3.c3a @@ -0,0 +1,11 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 1 + if 0 == 0 goto 1 + @2 = 0 +1 @1 = 1 + if @2 == 0 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/or1.c3a b/test/c3a-ref/or1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..844f198a06f4494ba75f96d77baaf97060b0a35b --- /dev/null +++ b/test/c3a-ref/or1.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 != 0 goto 1 + if 1 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/or2.c3a b/test/c3a-ref/or2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..894e598268c84cca18eb0d863e39c948a65442c4 --- /dev/null +++ b/test/c3a-ref/or2.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 != 0 goto 1 + if 0 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/or3.c3a b/test/c3a-ref/or3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..08ea85aa6d94c2a5dfe94c103eba494339f8aeba --- /dev/null +++ b/test/c3a-ref/or3.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 != 0 goto 1 + if 1 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/or4.c3a b/test/c3a-ref/or4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..dfe6660d1aa7f934d977a86f863ba518eb64437f --- /dev/null +++ b/test/c3a-ref/or4.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 != 0 goto 1 + if 0 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/or5.c3a b/test/c3a-ref/or5.c3a new file mode 100644 index 0000000000000000000000000000000000000000..c7fae5b38c326be24b53af91b2882a07b95cfeb2 --- /dev/null +++ b/test/c3a-ref/or5.c3a @@ -0,0 +1,15 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 != 0 goto 3 + if 1 != 0 goto 3 + @2 = 0 + goto 2 +3 @2 = 1 +2 if @2 != 0 goto 1 + if 0 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/parenth1.c3a b/test/c3a-ref/parenth1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..3cdcdf510ef3e817d53050b59f2954bdb1537b79 --- /dev/null +++ b/test/c3a-ref/parenth1.c3a @@ -0,0 +1,5 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + write 1 + fend diff --git a/test/c3a-ref/parenth2.c3a b/test/c3a-ref/parenth2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..ebfa3df44a1db8b187ce403d33e373c839aff8d9 --- /dev/null +++ b/test/c3a-ref/parenth2.c3a @@ -0,0 +1,5 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + write 2 + fend diff --git a/test/c3a-ref/prio23-1.c3a b/test/c3a-ref/prio23-1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..9b257f034be5f9a65aeea390a534ba3ecc2937e9 --- /dev/null +++ b/test/c3a-ref/prio23-1.c3a @@ -0,0 +1,9 @@ + t0 = call main + stop t0 +main fbegin #entree fonction + t1 = 1 + if 0 = 0 goto l0 + t1 = 0 +l0 t2 = t1 * 10 + write t2 + fend diff --git a/test/c3a-ref/prio23-2.c3a b/test/c3a-ref/prio23-2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..c675df7d6312b90e763dd5de2e3ea3846637d9e5 --- /dev/null +++ b/test/c3a-ref/prio23-2.c3a @@ -0,0 +1,9 @@ + t0 = call main + stop t0 +main fbegin #entree fonction + t1 = 1 + if 10 = 0 goto l0 + t1 = 0 +l0 t2 = 3 * t1 + write t2 + fend diff --git a/test/c3a-ref/prio23-3.c3a b/test/c3a-ref/prio23-3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..00a6d37b205203cb82f426fa64d27f7a11b06023 --- /dev/null +++ b/test/c3a-ref/prio23-3.c3a @@ -0,0 +1,9 @@ + t0 = call main + stop t0 +main fbegin #entree fonction + t1 = 1 + if 0 = 0 goto l0 + t1 = 0 +l0 t2 = t1 / 1 + write t2 + fend diff --git a/test/c3a-ref/prio23-4.c3a b/test/c3a-ref/prio23-4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..ac5ed732a4852c95d66de10c879e2029986902c9 --- /dev/null +++ b/test/c3a-ref/prio23-4.c3a @@ -0,0 +1,12 @@ + t0 = call main + stop t0 +main fbegin #entree fonction + t1 = 1 + if 1 = 0 goto l0 + t1 = 0 +l0 t2 = 1 + if 0 = 0 goto l1 + t2 = 0 +l1 t3 = t1 / t2 + write t3 + fend diff --git a/test/c3a-ref/prio34-1.c3a b/test/c3a-ref/prio34-1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..bf1aae0eccb51f1010e937e3dc020bf1b13926bc --- /dev/null +++ b/test/c3a-ref/prio34-1.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 3 * 4 + @2 = 2 + @1 + write @2 + fend diff --git a/test/c3a-ref/prio34-2.c3a b/test/c3a-ref/prio34-2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..599e604a702eaa13edaa1e7204a5c3a56bea5d2a --- /dev/null +++ b/test/c3a-ref/prio34-2.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 2 * 3 + @2 = @1 - 4 + write @2 + fend diff --git a/test/c3a-ref/prio34-3.c3a b/test/c3a-ref/prio34-3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..21ac788824d92e8cda4535e56a5106c35687f508 --- /dev/null +++ b/test/c3a-ref/prio34-3.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 6 / 3 + @2 = @1 - 72 + write @2 + fend diff --git a/test/c3a-ref/prio34-4.c3a b/test/c3a-ref/prio34-4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..5b08bc8575718d00eb5369f18ac7f87bf84ca876 --- /dev/null +++ b/test/c3a-ref/prio34-4.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 20 / 10 + @2 = 6 + @1 + write @2 + fend diff --git a/test/c3a-ref/prio45-1.c3a b/test/c3a-ref/prio45-1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..66f66e7f650a865ab5afd846e392db0e920db942 --- /dev/null +++ b/test/c3a-ref/prio45-1.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 0 + 1 + @1 = 1 + if 2 == @2 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/prio45-2.c3a b/test/c3a-ref/prio45-2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..194117811cc3fd6a710c5a47095d23779cd5204b --- /dev/null +++ b/test/c3a-ref/prio45-2.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 1 + 234 + @1 = 1 + if @2 == 1 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/prio45-3.c3a b/test/c3a-ref/prio45-3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..71e45e255e4bc70e98eb5e3440af00ab2578de58 --- /dev/null +++ b/test/c3a-ref/prio45-3.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 11 + 100 + @1 = 1 + if 12 < @2 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/prio45-4.c3a b/test/c3a-ref/prio45-4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..0b01672699919e70cc14e23035c3666edd8c0d64 --- /dev/null +++ b/test/c3a-ref/prio45-4.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 21 - 21 + @1 = 1 + if @2 < 1 goto 0 + @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/prio56-1.c3a b/test/c3a-ref/prio56-1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..683b54f60e6ca226c98f68606ed290091fabede8 --- /dev/null +++ b/test/c3a-ref/prio56-1.c3a @@ -0,0 +1,13 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 1 + if 1 == 2 goto 2 + @2 = 0 +2 if @2 == 0 goto 1 + if 1 == 0 goto 1 + @1 = 1 + goto 0 +1 @1 = 0 +0 write @1 + fend diff --git a/test/c3a-ref/prio56-2.c3a b/test/c3a-ref/prio56-2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..e9c62a78009bae3f9dda9511fc7c57b5aca21fad --- /dev/null +++ b/test/c3a-ref/prio56-2.c3a @@ -0,0 +1,13 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @2 = 1 + if 0 == 1 goto 2 + @2 = 0 +2 if 1 != 0 goto 1 + if @2 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/prio67-1.c3a b/test/c3a-ref/prio67-1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..ce8a86ee5c20b555f99cab09259ab143aa67cad9 --- /dev/null +++ b/test/c3a-ref/prio67-1.c3a @@ -0,0 +1,15 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 == 0 goto 3 + if 1 == 0 goto 3 + @2 = 1 + goto 2 +3 @2 = 0 +2 if @2 != 0 goto 1 + if 1 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/prio67-2.c3a b/test/c3a-ref/prio67-2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..684cec0adbee26c3ba96575c47c4db1011faad77 --- /dev/null +++ b/test/c3a-ref/prio67-2.c3a @@ -0,0 +1,15 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 == 0 goto 3 + if 0 == 0 goto 3 + @2 = 1 + goto 2 +3 @2 = 0 +2 if 1 != 0 goto 1 + if @2 != 0 goto 1 + @1 = 0 + goto 0 +1 @1 = 1 +0 write @1 + fend diff --git a/test/c3a-ref/rec1.c3a b/test/c3a-ref/rec1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..322131ac9406cc9562f72d8798e1328a0c0c26cd --- /dev/null +++ b/test/c3a-ref/rec1.c3a @@ -0,0 +1,22 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + @1 = 1 + if a == 1 goto 2 + @1 = 0 +2 if @1 == 0 goto 0 + ret 1 + fend + goto 1 +0 @3 = a - 1 + param @3 + @2 = call f + @4 = 1 + @2 + ret @4 + fend +1 fend +main fbegin #entree fonction + param 100 + @5 = call f + write @5 + fend diff --git a/test/c3a-ref/si1.c3a b/test/c3a-ref/si1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..fc0a9277972a7f6dfce324e08e772f38d8c8ec7f --- /dev/null +++ b/test/c3a-ref/si1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 == 0 goto 1 + write 1 +1 fend diff --git a/test/c3a-ref/si2.c3a b/test/c3a-ref/si2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..3bc635d4082a09bbc218553f9fc742a4ecd79da9 --- /dev/null +++ b/test/c3a-ref/si2.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 == 0 goto 0 + write 1 + goto 1 +0 write 0 +1 fend diff --git a/test/c3a-ref/si3.c3a b/test/c3a-ref/si3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..77f57ae4440addc24f849be6a74dd86883491f7b --- /dev/null +++ b/test/c3a-ref/si3.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 == 0 goto 0 + write 1 + goto 1 +0 write 0 +1 write 1 + fend diff --git a/test/c3a-ref/si4.c3a b/test/c3a-ref/si4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..48200340dab475a5354d6832db190c1e8242fb0c --- /dev/null +++ b/test/c3a-ref/si4.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 0 == 0 goto 0 + write 1 + goto 1 +0 write 0 +1 write 1 + fend diff --git a/test/c3a-ref/si5.c3a b/test/c3a-ref/si5.c3a new file mode 100644 index 0000000000000000000000000000000000000000..0b8d4f22a6e43890cab91f74be1381f4f21aac84 --- /dev/null +++ b/test/c3a-ref/si5.c3a @@ -0,0 +1,9 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + if 1 == 0 goto 3 + write 1 + if 1 == 0 goto 3 + write 1 +3 write 1 + fend diff --git a/test/c3a-ref/sub1.c3a b/test/c3a-ref/sub1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..1b0e46f521b7dd9f3f7538c3409bcc981ea3ca03 --- /dev/null +++ b/test/c3a-ref/sub1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 10 - 5 + write @1 + fend diff --git a/test/c3a-ref/sub2.c3a b/test/c3a-ref/sub2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..e4899730592e03554d3cd8737fee608259c1ddd6 --- /dev/null +++ b/test/c3a-ref/sub2.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 7 - 20 + write @1 + fend diff --git a/test/c3a-ref/sub3.c3a b/test/c3a-ref/sub3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..7ccf2bf30f0dd1bea0290b157f321e8c0c123c56 --- /dev/null +++ b/test/c3a-ref/sub3.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + @1 = 2 - 1 + @2 = @1 - 1 + write @2 + fend diff --git a/test/c3a-ref/tab1.c3a b/test/c3a-ref/tab1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..453f47238ae6ce5088f0da724298466425dacfce --- /dev/null +++ b/test/c3a-ref/tab1.c3a @@ -0,0 +1,10 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + tab[0] = 0 + tab[1] = 1 + tab[2] = 2 + write tab[0] + write tab[1] + write tab[2] + fend diff --git a/test/c3a-ref/tab2.c3a b/test/c3a-ref/tab2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..db4c77a3e13a4a31c3e30c645ffb97f475704381 --- /dev/null +++ b/test/c3a-ref/tab2.c3a @@ -0,0 +1,14 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + base = 2 + @1 = base + 0 + tab[@1] = 34 + @2 = base + 1 + tab[@2] = 74 + @3 = base + 2 + tab[@3] = 16 + write tab[2] + write tab[3] + write tab[4] + fend diff --git a/test/c3a-ref/tab3.c3a b/test/c3a-ref/tab3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..2483abb4aef86e62611fe5c7136d174ad75e6a25 --- /dev/null +++ b/test/c3a-ref/tab3.c3a @@ -0,0 +1,17 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + base = 2 + offset = 0 + @1 = base + offset + tab[@1] = 34 + offset = 1 + @2 = base + offset + tab[@2] = 74 + offset = 2 + @3 = base + offset + tab[@3] = 16 + write tab[2] + write tab[3] + write tab[4] + fend diff --git a/test/c3a-ref/tab4.c3a b/test/c3a-ref/tab4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..1613664598935700ec7afd0d7c0e3db6374d25e2 --- /dev/null +++ b/test/c3a-ref/tab4.c3a @@ -0,0 +1,11 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + tab[0] = 1 + tab[tab[0]] = 12 + @1 = tab[0] + 1 + tab[@1] = 13 + write tab[0] + write tab[1] + write tab[2] + fend diff --git a/test/c3a-ref/tantque1.c3a b/test/c3a-ref/tantque1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..78d3f86ed196912bcae10b1dd05610142cb4c377 --- /dev/null +++ b/test/c3a-ref/tantque1.c3a @@ -0,0 +1,14 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + a = 10 +0 @1 = 1 + if 0 < a goto 2 + @1 = 0 +2 if @1 == 0 goto 1 + write a + @2 = a - 1 + a = @2 + goto 0 +1 write 0 + fend diff --git a/test/c3a-ref/tantque2.c3a b/test/c3a-ref/tantque2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..3adbfa490ac4671c48e06487d5c38e68d765b0b8 --- /dev/null +++ b/test/c3a-ref/tantque2.c3a @@ -0,0 +1,22 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + a = 0 +0 @1 = 1 + if a < 4 goto 2 + @1 = 0 +2 if @1 == 0 goto 1 + b = 0 +3 @2 = 1 + if b < 4 goto 5 + @2 = 0 +5 if @2 == 0 goto 4 + write a + write b + @3 = b + 1 + b = @3 + goto 3 +4 @4 = a + 1 + a = @4 + goto 0 +1 fend diff --git a/test/c3a-ref/tri.c3a b/test/c3a-ref/tri.c3a new file mode 100644 index 0000000000000000000000000000000000000000..f1052ff30ba56e7a28323050217219a85f3e92ca --- /dev/null +++ b/test/c3a-ref/tri.c3a @@ -0,0 +1,71 @@ + @0 = call main + stop @0 +initialiser fbegin #entree fonction + tab[0] = 8 + tab[1] = 6 + tab[2] = 9 + tab[3] = 9 + tab[4] = 4 + tab[5] = 2 + tab[6] = 3 + tab[7] = 1 + tab[8] = 4 + tab[9] = 5 + fend +afficher fbegin #entree fonction + i = 0 +0 @1 = 1 + if i < n goto 2 + @1 = 0 +2 if @1 == 0 goto 1 + write tab[i] + @2 = i + 1 + i = @2 + goto 0 +1 write 0 + fend +echanger fbegin #entree fonction + temp = tab[j] + tab[j] = tab[i] + tab[i] = temp + fend +trier fbegin #entree fonction + m = n + echange = 1 +3 @3 = 1 + if echange == 1 goto 5 + @3 = 0 +5 if @3 == 0 goto 4 + echange = 0 + j = 0 +6 @5 = m - 1 + @4 = 1 + if j < @5 goto 8 + @4 = 0 +8 if @4 == 0 goto 7 + @7 = j + 1 + @6 = 1 + if tab[@7] < tab[j] goto 11 + @6 = 0 +11 if @6 == 0 goto 10 + param j + @9 = j + 1 + param @9 + @8 = call echanger + echange = 1 +10 @10 = j + 1 + j = @10 + goto 6 +7 @11 = m - 1 + m = @11 + goto 3 +4 fend +main fbegin #entree fonction + @12 = call initialiser + param 10 + @13 = call afficher + param 10 + @14 = call trier + param 10 + @15 = call afficher + fend diff --git a/test/c3a-ref/varglob1.c3a b/test/c3a-ref/varglob1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..c681ada75f67040a6948b8e79e5eb5fcd31e75c9 --- /dev/null +++ b/test/c3a-ref/varglob1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + variable = 6834 + write variable + fend diff --git a/test/c3a-ref/varglob2.c3a b/test/c3a-ref/varglob2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..bdaee5047b6ffbef66e24800560520cea008267a --- /dev/null +++ b/test/c3a-ref/varglob2.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + variable = 10 + @1 = variable + 50 + write @1 + fend diff --git a/test/c3a-ref/varglob3.c3a b/test/c3a-ref/varglob3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..eb8ce562ce5c4b5c5f3d0eeab1c691b9de909712 --- /dev/null +++ b/test/c3a-ref/varglob3.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + var1 = 10 + var2 = 34 + write var1 + write var2 + fend diff --git a/test/c3a-ref/varglob4.c3a b/test/c3a-ref/varglob4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..c5b8635e8068130a9410e7995a82fca82e4ccff4 --- /dev/null +++ b/test/c3a-ref/varglob4.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + var1 = 10 + var2 = 34 + @1 = var1 + var2 + write @1 + fend diff --git a/test/c3a-ref/varloc1.c3a b/test/c3a-ref/varloc1.c3a new file mode 100644 index 0000000000000000000000000000000000000000..c681ada75f67040a6948b8e79e5eb5fcd31e75c9 --- /dev/null +++ b/test/c3a-ref/varloc1.c3a @@ -0,0 +1,6 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + variable = 6834 + write variable + fend diff --git a/test/c3a-ref/varloc2.c3a b/test/c3a-ref/varloc2.c3a new file mode 100644 index 0000000000000000000000000000000000000000..bdaee5047b6ffbef66e24800560520cea008267a --- /dev/null +++ b/test/c3a-ref/varloc2.c3a @@ -0,0 +1,7 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + variable = 10 + @1 = variable + 50 + write @1 + fend diff --git a/test/c3a-ref/varloc3.c3a b/test/c3a-ref/varloc3.c3a new file mode 100644 index 0000000000000000000000000000000000000000..7dbbadb8d617aaef09863c28279e5c77cef6955e --- /dev/null +++ b/test/c3a-ref/varloc3.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + var1 = 10 + var2 = 30 + write var1 + write var2 + fend diff --git a/test/c3a-ref/varloc4.c3a b/test/c3a-ref/varloc4.c3a new file mode 100644 index 0000000000000000000000000000000000000000..71e8be70dfed719b17f12563e193ca461d575e7a --- /dev/null +++ b/test/c3a-ref/varloc4.c3a @@ -0,0 +1,8 @@ + @0 = call main + stop @0 +main fbegin #entree fonction + var1 = 10 + var2 = 30 + @1 = var1 + var2 + write @1 + fend diff --git a/test/c3a-ref/varloc5.c3a b/test/c3a-ref/varloc5.c3a new file mode 100644 index 0000000000000000000000000000000000000000..3c183068932e6094ec7b19c960dc777fa68b7c13 --- /dev/null +++ b/test/c3a-ref/varloc5.c3a @@ -0,0 +1,11 @@ + @0 = call main + stop @0 +f fbegin #entree fonction + var1 = 10 + write var1 + fend +main fbegin #entree fonction + var1 = 20 + @1 = call f + write var1 + fend diff --git a/test/evaluate.py b/test/evaluate.py new file mode 100755 index 0000000000000000000000000000000000000000..febaaf25b8cfd221f36fb690f76da55d10ae42ab --- /dev/null +++ b/test/evaluate.py @@ -0,0 +1,473 @@ +#! /usr/bin/python3 -u + +import sys +import os +import subprocess +import inspect +import argparse + +# code de sortie du compilateur + +NOERROR_CODE = 0 +ERR_TYPE_CODE = 3 +ERR_SYMBOL_TABLE_CODE = 4 +ERR_SYNTAX_CODE = 5 +ERR_LEX_CODE = 6 + +# coefficients pour le calcul de la note finale +SC_COEFF = 4 +SA_DIFF_COEFF = 0 +TS_DIFF_COEFF = 0 +SA_COEFF = 3 +C3A_DIFF_COEFF = 0 +C3A_COEFF = 3 +PRE_NASM_DIFF = 0 +PRE_NASM_COEFF = 3 +NASM_DIFF_COEFF = 0 +NASM_COEFF = 3 +EXE_COEFF = 0 +ERR_TS_COEFF = 2 +ERR_TYPE_COEFF = 2 + +# Paths relative to this file (evaluate.py) +inputPath = "./input/" +errInputPathTs = "./input_err_ts/" +errInputPathType = "./input_err_type/" +refPath = "./" +srcPath = "../src/" +# Keep empty +classpath = "" +# Outputs files (don't change this, it's set in the main) +outErr = sys.stderr +outScore = sys.stdout +outVerbose = open(os.devnull,"w") +outputFilename = "result.txt" + +################################################################################ +def compileCompiler() : + global classpath + for file in ["Compiler.java", "SaVM.java", "C3aVM.java", "NasmVM.java"] : + if not os.path.isfile(srcPath+file) : + print("Skipping compilation of %s"%file, file=outVerbose) + continue + package = file.lower().split('.')[0].replace('vm', '') + if package in ["c3a", "nasm"] and not os.path.isdir(srcPath+package) : + print("Skipping compilation of %s"%file, file=outVerbose) + continue + print("Compiling %s..."%file, end="", file=outVerbose) + proc = subprocess.Popen("cd %s && javac %s %s %s"%(srcPath, "-cp " if len(classpath) > 0 else "", classpath, file), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + errMess = proc.stderr.read().decode('utf8') + returnCode = proc.wait() + if returnCode == 0 : + print("Done", file=outVerbose) + else : + print("", file=outVerbose) + print("ERROR !", file=outErr) + print(errMess, file=outErr) + exit(1) + print("", file=outVerbose) + classpath = "../xerces-2_12_1/*:%s"%srcPath + classpath = "" +################################################################################ + +################################################################################ +def deleteClasses() : + + for root, subdirs, files in os.walk("%s.."%srcPath) : + if ".git" in root : + continue + for filename in files : + if os.path.splitext(filename)[1] == ".class" : + os.remove(root+"/"+filename) + + return classpath +################################################################################ + +################################################################################ +def findClasspath() : + global classpath + + if len(classpath) > 0 : + return classpath + + for root, subdirs, files in os.walk("%s.."%srcPath) : + if ".git" in root : + continue + for filename in files : + if os.path.splitext(filename)[1] in [".class", ".jar"] : + classpath += ("" if len(classpath) == 0 else ":") + root + break + + classpath += ("" if len(classpath) == 0 else ":")+"../xerces-2_12_1/*" + return classpath +################################################################################ + +################################################################################ +def compiler(verbose="-v 2") : + return "java -classpath %s Compiler %s"%(findClasspath(), verbose) +################################################################################ + +################################################################################ +def green(string) : + return "\033[92m%s\033[0m"%string +################################################################################ + +################################################################################ +def purple(string) : + return "\033[95m%s\033[0m"%string +################################################################################ + +################################################################################ +def red(string) : + return "\033[91m%s\033[0m"%string +################################################################################ + +################################################################################ +def changeExtension(filename, newExtension) : + return os.path.splitext(filename)[0] + newExtension +################################################################################ + +################################################################################ +def findInputFiles(path) : + inputFiles = [] + for filename in os.listdir(path) : + if os.path.splitext(filename)[1] == ".l" : + inputFiles.append(filename) + inputFiles.sort() + return inputFiles +################################################################################ + +################################################################################ +def deleteCompilationOutputs() : + outputExtensions = [".exe", ".exeout", ".o", ".out", ".sa", ".saout", ".sc", ".ts", ".nasm", ".nasmout", ".pre-nasm", ".pre-nasmout", ".c3a", ".c3aout", ".fg", ".fgs", ".ig"] + for filename in os.listdir(inputPath) : + if os.path.splitext(filename)[1] in outputExtensions : + os.remove(inputPath+filename) +################################################################################ + +################################################################################ +def compileInputFiles(inputFiles) : + evaluation = getNewEvaluationResult(ERR_SYNTAX_CODE) + for inputFile in inputFiles : + lightFilename = inputFile.split("/")[-1] + print("Compiling %s..."%inputFile, file=outVerbose, flush=True, end='') + returnCode = subprocess.Popen("{} {}{}".format(compiler(), inputPath, inputFile), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).wait() + if returnCode == NOERROR_CODE : + evaluation[1]["correct"].append(lightFilename) + print("Done", file=outVerbose) + else : + evaluation[1]["incorrect"].append(lightFilename) + print("ERROR !", file=outErr) + print("", file=outVerbose) + return evaluation +################################################################################ + +################################################################################ +def getNewEvaluationResult(name) : + return [name, {"correct" : [], "incorrect" : [], "notfound" : []}] +################################################################################ + +################################################################################ +def evaluateCompilationErrors(inputFiles, expectedCode, name) : + evaluation = getNewEvaluationResult(name) + + print(file=outVerbose) + + for inputFile in inputFiles : + if not os.path.isfile(inputFile) : + print("ERROR : could not find '%s'"%inputFile, file=outErr) + exit(1) + lightFilename = inputFile.split("/")[-1] + print("Compiling %s..."%lightFilename, end="", file=outVerbose) + returnCode = subprocess.Popen("{} {}".format(compiler(verbose=""), inputFile), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).wait() + print("Done (%d)"%returnCode, file=outVerbose) + if returnCode == expectedCode : + evaluation[1]["correct"].append(lightFilename) + else : + evaluation[1]["incorrect"].append(lightFilename) + print("", file=outVerbose) + + return evaluation +################################################################################ + +################################################################################ +def evaluateDiff(inputFiles, extension, extensionRef, path, name) : + evaluation = getNewEvaluationResult(name) + + for filename in inputFiles : + producedFile = changeExtension(filename, extension) + if not os.path.isfile(inputPath+producedFile) : + evaluation[1]["notfound"].append(producedFile) + continue + + ref = refPath+path+changeExtension(producedFile, extensionRef) + if not os.path.isfile(ref) : + print("ATTENTION : Fichier non trouvé : %s"%ref, file=sys.stderr) + continue + + refContent = [] + for line in open(ref, "r") : + line = line.strip() + if len(line) > 0 : + refContent.append(line) + producedContent = [] + for line in open(inputPath+producedFile, "r") : + line = line.strip() + if len(line) > 0 : + producedContent.append(line) + + if producedContent == refContent : + evaluation[1]["correct"].append(producedFile) + else : + evaluation[1]["incorrect"].append(producedFile) + + return evaluation +################################################################################ + +################################################################################ +def evaluateSa(inputFiles) : + errs = [] + for filename in inputFiles : + saFilename = inputPath+changeExtension(filename, ".sa") + outFilename = inputPath+changeExtension(filename, ".saout") + if not os.path.isfile(saFilename) : + continue + + command = "java -classpath %s SaVM -sa %s > %s"%(findClasspath(), saFilename, outFilename) + out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode() + if len(out) != 0 : + errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out)) + + return evaluateDiff(inputFiles, ".saout", ".out", "out-ref/", "Execution de sa"), errs +################################################################################ + +################################################################################ +def evaluateC3a(inputFiles) : + errs = [] + for filename in inputFiles : + c3aFilename = inputPath+changeExtension(filename, ".c3a") + tsFilename = inputPath+changeExtension(filename, ".ts") + outFilename = inputPath+changeExtension(filename, ".c3aout") + if not os.path.isfile(c3aFilename) or not os.path.isfile(tsFilename) : + continue + + command = "java -classpath %s C3aVM -c3a %s -ts %s > %s"%(findClasspath(), c3aFilename, tsFilename, outFilename) + out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode() + if len(out) != 0 : + errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out)) + + return evaluateDiff(inputFiles, ".c3aout", ".out", "out-ref/", "Execution du c3a"), errs +################################################################################ + +################################################################################ +def evaluatePreNasm(inputFiles) : + errs = [] + for filename in inputFiles : + nasmFilename = inputPath+changeExtension(filename, ".pre-nasm") + outFilename = inputPath+changeExtension(filename, ".pre-nasmout") + if not os.path.isfile(nasmFilename) : + continue + + command = "java -classpath %s NasmVM -nasm %s > %s"%(findClasspath(), nasmFilename, outFilename) + out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode() + if len(out) != 0 : + errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out)) + + return evaluateDiff(inputFiles, ".pre-nasmout", ".out", "out-ref/", "Execution du pre-nasm"), errs +################################################################################ + +################################################################################ +def evaluateNasm(inputFiles) : + errs = [] + for filename in inputFiles : + nasmFilename = inputPath+changeExtension(filename, ".nasm") + outFilename = inputPath+changeExtension(filename, ".nasmout") + if not os.path.isfile(nasmFilename) : + continue + + command = "java -classpath %s NasmVM -nasm %s > %s"%(findClasspath(), nasmFilename, outFilename) + out = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read().decode() + if len(out) != 0 : + errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out)) + + return evaluateDiff(inputFiles, ".nasmout", ".out", "out-ref/", "Execution du nasm"), errs +################################################################################ + +################################################################################ +def evaluateExecutable(inputFiles) : + errs = [] + for filename in inputFiles : + nasmFilename = changeExtension(filename, ".nasm") + objectFilename = changeExtension(filename, ".o") + execFilename = changeExtension(filename, ".exe") + outFilename = changeExtension(filename, ".exeout") + if not os.path.isfile(inputPath+nasmFilename) : + continue + + out = subprocess.Popen("cd {} && nasm -f elf -dwarf -g {}".format(inputPath+"..","input/"+nasmFilename), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read() + if not os.path.isfile(inputPath+objectFilename) : + errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out)) + continue + out = subprocess.Popen("ld -m elf_i386 -o {}{} {}{}".format(inputPath,execFilename,inputPath,objectFilename), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read() + if not os.path.isfile(inputPath+execFilename) : + errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out)) + continue + out = subprocess.Popen("{}{} > {}{}".format(inputPath,execFilename,inputPath,outFilename), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stderr.read() + if not os.path.isfile(inputPath+outFilename) : + errs.append("ERROR %s for input %s : '%s'"%(inspect.stack()[0][3], filename, out)) + continue + + return evaluateDiff(inputFiles, ".exeout", ".out", "out-ref/", "Execution du binaire"), errs +################################################################################ + +################################################################################ +def printListElements(destination, elements, colorFunction, useColor, resultStr) : + if len(elements) == 0 : + return + maxColumnSize = len(max(elements, key=len)) + for filename in elements : + if useColor : + print("\t{}".format(colorFunction(filename)), file=destination) + else : + print("\t{:{}} {}".format(filename, maxColumnSize+2, resultStr), file=destination) +################################################################################ + +################################################################################ +def printEvaluationResult(destination, evaluationResult, useColor) : + name = evaluationResult[0] + correct = evaluationResult[1]["correct"] + incorrect = evaluationResult[1]["incorrect"] + notfound = evaluationResult[1]["notfound"] + + nbCorrect = len(correct) + nbTotal = len(correct) + len(incorrect) + len(notfound) + + score = 0.0 + if nbTotal > 0 : + score = 100.0*nbCorrect/nbTotal + for dest, color in [(destination, useColor), (open(outputFilename, "a"), False)] : + print("Évaluation de %s :"%name, file=dest) + print("{}/{} correct ({:6.2f}%)".format(nbCorrect, nbTotal, score), file=dest) + if nbCorrect+len(incorrect) > 0 : + printListElements(dest, correct, green, color, "CORRECT") + printListElements(dest, incorrect, purple, color, "INCORRECT") + printListElements(dest, notfound, red, color, "NON-EXISTANT") + return score +################################################################################ + +################################################################################ +if __name__ == "__main__" : + parser = argparse.ArgumentParser() + parser.add_argument("--verbose", "-v", default=False, action="store_true", + help="Verbose output (obsolete, verbose is default).") + parser.add_argument("--silent", "-s", default=False, action="store_true", + help="Less verbose output.") + parser.add_argument("--noColors", default=False, action="store_true", + help="Disable colors in output.") + parser.add_argument("--clean", "-c", default=False, action="store_true", + help="Clean input dir then exit.") + parser.add_argument("--number", "-n", default=None, type=int, + help="Restrict tests to n inputs.") + parser.add_argument("--files", "-f", default=[], nargs="*", + help="Specify input files.") + args = parser.parse_args() + + args.verbose = not args.silent + + if args.verbose : + outVerbose = outScore + if args.clean : + deleteCompilationOutputs() + exit(0) + + with open(outputFilename, "w") as _ : + pass + + inputFiles = args.files[:args.number] + if len(inputFiles) == 0 : + inputFiles = findInputFiles(inputPath)[:args.number] + + errInputFilesTs = [errInputPathTs+"/"+f for f in findInputFiles(errInputPathTs)[:args.number]] + errInputFilesType = [errInputPathType+"/"+f for f in findInputFiles(errInputPathType)[:args.number]] + + deleteCompilationOutputs() + + compileCompiler() + + + scores = [] + names = [] + errors = [] + names.append("SC ") + res = compileInputFiles(inputFiles) + scores.append(printEvaluationResult(outVerbose, res, not args.noColors)) + msg = "Diff de %s" + dfSa = lambda files : (evaluateDiff(inputFiles, ".sa", ".sa", "sa-ref/", msg%"sa"), []) + dfTs = lambda files : (evaluateDiff(inputFiles, ".ts", ".ts", "ts-ref/", msg%"ts"), []) + dfC3a = lambda files : (evaluateDiff(inputFiles, ".c3a", ".c3a", "c3a-ref/", msg%"c3a"), []) + dfPreNasm = lambda files : (evaluateDiff(inputFiles, ".pre-nasm", ".pre-nasm", "pre-nasm-ref/", msg%"pre-nasm"), []) + dfNasm = lambda files : (evaluateDiff(inputFiles, ".nasm", ".nasm", "nasm-ref/", msg%"nasm"), []) + + # Evaluation of normal (working) examples + for evalTarget in [ + ("SA-DIFF ", dfSa), + ("TS-DIFF ", dfTs), + ("SA ", evaluateSa), + ("C3A-DIFF ", dfC3a), + ("C3A ", evaluateC3a), + ("PRE-NASM-DIFF", dfPreNasm), + ("PRE-NASM ", evaluatePreNasm), + ("NASM-DIFF ", dfNasm), + ("NASM ", evaluateNasm), + ("EXE ", evaluateExecutable), + ] : + names.append(evalTarget[0]) + res, err = evalTarget[1](inputFiles) + scores.append(printEvaluationResult(outVerbose, res, not args.noColors)) + errors += err + + # Evaluation of ill formed examples, that should trigger a compilation error + for evalTarget in [ + ("ERR_TS ", evaluateCompilationErrors, errInputFilesTs, ERR_SYMBOL_TABLE_CODE), + ("ERR_TYPE ", evaluateCompilationErrors, errInputFilesType, ERR_TYPE_CODE), + ] : + names.append(evalTarget[0]) + res = evalTarget[1](evalTarget[2], evalTarget[3], evalTarget[0]) + scores.append(printEvaluationResult(outVerbose, res, not args.noColors)) + + deleteClasses() + + # The rest of the script will now print the results + + if not args.noColors : + print("Légende : {} {} {}".format(green("CORRECT"), purple("INCORRECT"), red("NON-EXISTANT")), file=outVerbose) + + errorsStr = "" + + if len(errors) > 0 : + errorsStr = "%s\n%s"%((30*"-")+("EVALUATION ERRORS")+(30*"-"), "\n\n".join(errors)) + + print(errorsStr) + print(errorsStr, file=open(outputFilename, "a")) + + for i in range(len(scores)): + print(names[i], "\t", scores[i]) + + print("Copy-pastable scores :", file=outScore) + print("\t".join(names), file=outScore) + print("\t".join(["%6.2f"%scores[i] for i in range(len(scores))]), file=outScore) + + print("\nSauvegardé dans le fichier %s"%outputFilename) + +# les coefficients associés à chaque partie pour le calcul de la note finale + coeffs = [SC_COEFF, SA_DIFF_COEFF, TS_DIFF_COEFF, SA_COEFF, C3A_DIFF_COEFF, C3A_COEFF, PRE_NASM_DIFF, PRE_NASM_COEFF, NASM_DIFF_COEFF, NASM_COEFF, EXE_COEFF, ERR_TS_COEFF, ERR_TYPE_COEFF] + +# calcul de la note finale + + note = 0 + for i in range(len(scores)): + note += scores[i] / 100 * coeffs[i] + print ("note = ", note) + +################################################################################ + diff --git a/test/fg-ref/add1.fg b/test/fg-ref/add1.fg new file mode 100644 index 0000000000000000000000000000000000000000..c297a4b0cdcc49b86eeeee84cac8d8b15ee0b614 --- /dev/null +++ b/test/fg-ref/add1.fg @@ -0,0 +1,14 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 3 ; +8 : ( 9 ) add r0, 10 ; +9 : ( 10 ) mov eax, r0 ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) add esp, 0 ;désallocation des variables locales +12 : ( 13 ) pop ebp ;restaure la valeur de ebp +13 : ( ) ret ; diff --git a/test/fg-ref/add2.fg b/test/fg-ref/add2.fg new file mode 100644 index 0000000000000000000000000000000000000000..083fd7bb3f5294b4f0642a1a026e6fbc048433aa --- /dev/null +++ b/test/fg-ref/add2.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 2 ; +8 : ( 9 ) add r0, 4 ; +9 : ( 10 ) mov r1, r0 ; +10 : ( 11 ) add r1, 8 ; +11 : ( 12 ) mov eax, r1 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/affect1.fg b/test/fg-ref/affect1.fg new file mode 100644 index 0000000000000000000000000000000000000000..61923e559a20df2f28545356f23991fc6a510d07 --- /dev/null +++ b/test/fg-ref/affect1.fg @@ -0,0 +1,13 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov dword [a], 1 ;Affect +8 : ( 9 ) mov eax, dword [a] ;Write 1 +9 : ( ) call iprintLF ;Write 2 +10 : ( 11 ) add esp, 0 ;désallocation des variables locales +11 : ( 12 ) pop ebp ;restaure la valeur de ebp +12 : ( ) ret ; diff --git a/test/fg-ref/affect2.fg b/test/fg-ref/affect2.fg new file mode 100644 index 0000000000000000000000000000000000000000..a464fa66abc92e73a7454714248bcb4c439400fa --- /dev/null +++ b/test/fg-ref/affect2.fg @@ -0,0 +1,13 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 4 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 1 ;Affect +8 : ( 9 ) mov eax, dword [ebp-4*1] ;Write 1 +9 : ( ) call iprintLF ;Write 2 +10 : ( 11 ) add esp, 4 ;désallocation des variables locales +11 : ( 12 ) pop ebp ;restaure la valeur de ebp +12 : ( ) ret ; diff --git a/test/fg-ref/affect3.fg b/test/fg-ref/affect3.fg new file mode 100644 index 0000000000000000000000000000000000000000..333c3c4f694a5103f43227ca7273fb6a3e31399f --- /dev/null +++ b/test/fg-ref/affect3.fg @@ -0,0 +1,24 @@ +0 : ( 13 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp+4*3], 1 ;Affect +8 : ( 9 ) mov eax, dword [ebp+4*3] ;Write 1 +9 : ( ) call iprintLF ;Write 2 +10 : ( 11 ) add esp, 0 ;désallocation des variables locales +11 : ( 12 ) pop ebp ;restaure la valeur de ebp +12 : ( 13 ) ret ; +13 : ( 14 ) main : push ebp ;sauvegarde la valeur de ebp +14 : ( 15 ) mov ebp, esp ;nouvelle valeur de ebp +15 : ( 16 ) sub esp, 4 ;allocation des variables locales +16 : ( 17 ) push 3 ;Param +17 : ( 18 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +18 : ( 4 ) call f ; +19 : ( 20 ) pop r0 ;récupération de la valeur de retour +20 : ( 21 ) add esp, 4 ;désallocation des arguments +21 : ( 22 ) add esp, 4 ;désallocation des variables locales +22 : ( 23 ) pop ebp ;restaure la valeur de ebp +23 : ( ) ret ; diff --git a/test/fg-ref/and1.fg b/test/fg-ref/and1.fg new file mode 100644 index 0000000000000000000000000000000000000000..750f4f19d0e0a7af76586dc701ca28dc749dc6a8 --- /dev/null +++ b/test/fg-ref/and1.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 3 ;JumpIfEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) je l1 ;JumpIfEqual 2 +10 : ( 11 ) mov r4, 1 ;JumpIfEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) je l1 ;JumpIfEqual 2 +13 : ( 14 ) mov r0, 1 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 0 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/and2.fg b/test/fg-ref/and2.fg new file mode 100644 index 0000000000000000000000000000000000000000..2a49f43dacb2a0742154fa625df1c052658b837a --- /dev/null +++ b/test/fg-ref/and2.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 4 ;JumpIfEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) je l1 ;JumpIfEqual 2 +10 : ( 11 ) mov r4, 0 ;JumpIfEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) je l1 ;JumpIfEqual 2 +13 : ( 14 ) mov r0, 1 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 0 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/and3.fg b/test/fg-ref/and3.fg new file mode 100644 index 0000000000000000000000000000000000000000..5a994c3f036918fb7952b07da87a605a7749e359 --- /dev/null +++ b/test/fg-ref/and3.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 0 ;JumpIfEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) je l1 ;JumpIfEqual 2 +10 : ( 11 ) mov r4, 1024 ;JumpIfEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) je l1 ;JumpIfEqual 2 +13 : ( 14 ) mov r0, 1 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 0 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/and4.fg b/test/fg-ref/and4.fg new file mode 100644 index 0000000000000000000000000000000000000000..3c441deef07b0435c6ca6ff339189a87d2cbce7b --- /dev/null +++ b/test/fg-ref/and4.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 0 ;JumpIfEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) je l1 ;JumpIfEqual 2 +10 : ( 11 ) mov r4, 0 ;JumpIfEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) je l1 ;JumpIfEqual 2 +13 : ( 14 ) mov r0, 1 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 0 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/and5.fg b/test/fg-ref/and5.fg new file mode 100644 index 0000000000000000000000000000000000000000..479056ecfdcff913dab31c24c5fa886641d18ec4 --- /dev/null +++ b/test/fg-ref/and5.fg @@ -0,0 +1,29 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r4, 1 ;JumpIfEqual 1 +8 : ( 9 ) cmp r4, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) je l3 ;JumpIfEqual 2 +10 : ( 11 ) mov r5, 0 ;JumpIfEqual 1 +11 : ( 12 ) cmp r5, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) je l3 ;JumpIfEqual 2 +13 : ( 14 ) mov r1, 1 ;Affect +14 : ( 16 ) jmp l2 ;Jump +15 : ( 16 ) l3 : mov r1, 0 ;Affect +16 : ( 17 ) l2 : cmp r1, 0 ;JumpIfEqual 1 +17 : ( 18 23 ) je l1 ;JumpIfEqual 2 +18 : ( 19 ) mov r6, 1 ;JumpIfEqual 1 +19 : ( 20 ) cmp r6, 0 ;on passe par un registre temporaire +20 : ( 21 23 ) je l1 ;JumpIfEqual 2 +21 : ( 22 ) mov r0, 1 ;Affect +22 : ( 24 ) jmp l0 ;Jump +23 : ( 24 ) l1 : mov r0, 0 ;Affect +24 : ( 25 ) l0 : mov eax, r0 ;Write 1 +25 : ( ) call iprintLF ;Write 2 +26 : ( 27 ) add esp, 0 ;désallocation des variables locales +27 : ( 28 ) pop ebp ;restaure la valeur de ebp +28 : ( ) ret ; diff --git a/test/fg-ref/appel-param1.fg b/test/fg-ref/appel-param1.fg new file mode 100644 index 0000000000000000000000000000000000000000..41c20bf55f8ac21eb76c7f3c08ed369f540a61ed --- /dev/null +++ b/test/fg-ref/appel-param1.fg @@ -0,0 +1,23 @@ +0 : ( 12 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, dword [ebp+4*3] ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( 12 ) ret ; +12 : ( 13 ) main : push ebp ;sauvegarde la valeur de ebp +13 : ( 14 ) mov ebp, esp ;nouvelle valeur de ebp +14 : ( 15 ) sub esp, 0 ;allocation des variables locales +15 : ( 16 ) push 1 ;Param +16 : ( 17 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +17 : ( 4 ) call f ; +18 : ( 19 ) pop r0 ;récupération de la valeur de retour +19 : ( 20 ) add esp, 4 ;désallocation des arguments +20 : ( 21 ) add esp, 0 ;désallocation des variables locales +21 : ( 22 ) pop ebp ;restaure la valeur de ebp +22 : ( ) ret ; diff --git a/test/fg-ref/appel-param2.fg b/test/fg-ref/appel-param2.fg new file mode 100644 index 0000000000000000000000000000000000000000..4b41c8033a613e3d8815c76b6b52d169ea05832c --- /dev/null +++ b/test/fg-ref/appel-param2.fg @@ -0,0 +1,26 @@ +0 : ( 14 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, dword [ebp+4*4] ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) mov eax, dword [ebp+4*3] ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) add esp, 0 ;désallocation des variables locales +12 : ( 13 ) pop ebp ;restaure la valeur de ebp +13 : ( 14 ) ret ; +14 : ( 15 ) main : push ebp ;sauvegarde la valeur de ebp +15 : ( 16 ) mov ebp, esp ;nouvelle valeur de ebp +16 : ( 17 ) sub esp, 0 ;allocation des variables locales +17 : ( 18 ) push 1 ;Param +18 : ( 19 ) push 456 ;Param +19 : ( 20 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +20 : ( 4 ) call f ; +21 : ( 22 ) pop r0 ;récupération de la valeur de retour +22 : ( 23 ) add esp, 8 ;désallocation des arguments +23 : ( 24 ) add esp, 0 ;désallocation des variables locales +24 : ( 25 ) pop ebp ;restaure la valeur de ebp +25 : ( ) ret ; diff --git a/test/fg-ref/appel-param3.fg b/test/fg-ref/appel-param3.fg new file mode 100644 index 0000000000000000000000000000000000000000..a4d722885c65c145f81518b5290a2f3bf7d4e3d6 --- /dev/null +++ b/test/fg-ref/appel-param3.fg @@ -0,0 +1,35 @@ +0 : ( 20 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, dword [ebp+4*7] ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) mov eax, dword [ebp+4*6] ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) mov eax, dword [ebp+4*5] ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) mov eax, dword [ebp+4*4] ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) mov eax, dword [ebp+4*3] ;Write 1 +16 : ( ) call iprintLF ;Write 2 +17 : ( 18 ) add esp, 0 ;désallocation des variables locales +18 : ( 19 ) pop ebp ;restaure la valeur de ebp +19 : ( 20 ) ret ; +20 : ( 21 ) main : push ebp ;sauvegarde la valeur de ebp +21 : ( 22 ) mov ebp, esp ;nouvelle valeur de ebp +22 : ( 23 ) sub esp, 0 ;allocation des variables locales +23 : ( 24 ) push 1 ;Param +24 : ( 25 ) push 2 ;Param +25 : ( 26 ) push 3 ;Param +26 : ( 27 ) push 4 ;Param +27 : ( 28 ) push 5 ;Param +28 : ( 29 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +29 : ( 4 ) call f ; +30 : ( 31 ) pop r0 ;récupération de la valeur de retour +31 : ( 32 ) add esp, 20 ;désallocation des arguments +32 : ( 33 ) add esp, 0 ;désallocation des variables locales +33 : ( 34 ) pop ebp ;restaure la valeur de ebp +34 : ( ) ret ; diff --git a/test/fg-ref/appel-retour1.fg b/test/fg-ref/appel-retour1.fg new file mode 100644 index 0000000000000000000000000000000000000000..dc08c96b52c2860645051c11d697e5c9ae1c0243 --- /dev/null +++ b/test/fg-ref/appel-retour1.fg @@ -0,0 +1,25 @@ +0 : ( 12 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, dword [ebp+4*3] ;ecriture de la valeur de retour +8 : ( 9 ) mov dword [ebp+4*2], r3 ;on passe par un registre temporaire +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( 12 ) ret ; +12 : ( 13 ) main : push ebp ;sauvegarde la valeur de ebp +13 : ( 14 ) mov ebp, esp ;nouvelle valeur de ebp +14 : ( 15 ) sub esp, 0 ;allocation des variables locales +15 : ( 16 ) push 3712 ;Param +16 : ( 17 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +17 : ( 4 ) call f ; +18 : ( 19 ) pop r0 ;récupération de la valeur de retour +19 : ( 20 ) add esp, 4 ;désallocation des arguments +20 : ( 21 ) mov eax, r0 ;Write 1 +21 : ( ) call iprintLF ;Write 2 +22 : ( 23 ) add esp, 0 ;désallocation des variables locales +23 : ( 24 ) pop ebp ;restaure la valeur de ebp +24 : ( ) ret ; diff --git a/test/fg-ref/appel1.fg b/test/fg-ref/appel1.fg new file mode 100644 index 0000000000000000000000000000000000000000..c3ca7daf7e5385c26a4dd80fddb071f661c00e21 --- /dev/null +++ b/test/fg-ref/appel1.fg @@ -0,0 +1,21 @@ +0 : ( 12 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 1 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( 12 ) ret ; +12 : ( 13 ) main : push ebp ;sauvegarde la valeur de ebp +13 : ( 14 ) mov ebp, esp ;nouvelle valeur de ebp +14 : ( 15 ) sub esp, 0 ;allocation des variables locales +15 : ( 16 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +16 : ( 4 ) call f ; +17 : ( 18 ) pop r0 ;récupération de la valeur de retour +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/appel2.fg b/test/fg-ref/appel2.fg new file mode 100644 index 0000000000000000000000000000000000000000..5dd804608886472fd1647cecd98d3a64224fe559 --- /dev/null +++ b/test/fg-ref/appel2.fg @@ -0,0 +1,32 @@ +0 : ( 23 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) g : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 2 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( 12 ) ret ; +12 : ( 13 ) f : push ebp ;sauvegarde la valeur de ebp +13 : ( 14 ) mov ebp, esp ;nouvelle valeur de ebp +14 : ( 15 ) sub esp, 0 ;allocation des variables locales +15 : ( 16 ) mov eax, 1 ;Write 1 +16 : ( ) call iprintLF ;Write 2 +17 : ( 18 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +18 : ( 4 ) call g ; +19 : ( 20 ) pop r0 ;récupération de la valeur de retour +20 : ( 21 ) add esp, 0 ;désallocation des variables locales +21 : ( 22 ) pop ebp ;restaure la valeur de ebp +22 : ( 23 ) ret ; +23 : ( 24 ) main : push ebp ;sauvegarde la valeur de ebp +24 : ( 25 ) mov ebp, esp ;nouvelle valeur de ebp +25 : ( 26 ) sub esp, 0 ;allocation des variables locales +26 : ( 27 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +27 : ( 12 ) call f ; +28 : ( 29 ) pop r1 ;récupération de la valeur de retour +29 : ( 30 ) add esp, 0 ;désallocation des variables locales +30 : ( 31 ) pop ebp ;restaure la valeur de ebp +31 : ( ) ret ; diff --git a/test/fg-ref/appel3.fg b/test/fg-ref/appel3.fg new file mode 100644 index 0000000000000000000000000000000000000000..d4964b38d5e6f891f2d9a655f9b12f9cc5216d17 --- /dev/null +++ b/test/fg-ref/appel3.fg @@ -0,0 +1,32 @@ +0 : ( 20 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) g : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 2 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( 12 ) ret ; +12 : ( 13 ) f : push ebp ;sauvegarde la valeur de ebp +13 : ( 14 ) mov ebp, esp ;nouvelle valeur de ebp +14 : ( 15 ) sub esp, 0 ;allocation des variables locales +15 : ( 16 ) mov eax, 1 ;Write 1 +16 : ( ) call iprintLF ;Write 2 +17 : ( 18 ) add esp, 0 ;désallocation des variables locales +18 : ( 19 ) pop ebp ;restaure la valeur de ebp +19 : ( 20 ) ret ; +20 : ( 21 ) main : push ebp ;sauvegarde la valeur de ebp +21 : ( 22 ) mov ebp, esp ;nouvelle valeur de ebp +22 : ( 23 ) sub esp, 0 ;allocation des variables locales +23 : ( 24 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +24 : ( 12 ) call f ; +25 : ( 26 ) pop r0 ;récupération de la valeur de retour +26 : ( 27 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +27 : ( 4 ) call g ; +28 : ( 29 ) pop r1 ;récupération de la valeur de retour +29 : ( 30 ) add esp, 0 ;désallocation des variables locales +30 : ( 31 ) pop ebp ;restaure la valeur de ebp +31 : ( ) ret ; diff --git a/test/fg-ref/div1.fg b/test/fg-ref/div1.fg new file mode 100644 index 0000000000000000000000000000000000000000..eccd4daf88b1b827ad5b8c6cce1de005c22276c4 --- /dev/null +++ b/test/fg-ref/div1.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 4 ; +8 : ( 9 ) mov r4, 2 ; +9 : ( 10 ) idiv r4 ; +10 : ( 11 ) mov r0, eax ; +11 : ( 12 ) mov eax, r0 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/div2.fg b/test/fg-ref/div2.fg new file mode 100644 index 0000000000000000000000000000000000000000..7a56fa1e252641e8788a12e7304f29a47177f723 --- /dev/null +++ b/test/fg-ref/div2.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 0 ; +8 : ( 9 ) mov r4, 712 ; +9 : ( 10 ) idiv r4 ; +10 : ( 11 ) mov r0, eax ; +11 : ( 12 ) mov eax, r0 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/div3.fg b/test/fg-ref/div3.fg new file mode 100644 index 0000000000000000000000000000000000000000..a7e922490cfbe32a9e48acbdb64e96335dddeab5 --- /dev/null +++ b/test/fg-ref/div3.fg @@ -0,0 +1,20 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 4 ; +8 : ( 9 ) mov r5, 2 ; +9 : ( 10 ) idiv r5 ; +10 : ( 11 ) mov r0, eax ; +11 : ( 12 ) mov eax, r0 ; +12 : ( 13 ) mov r8, 2 ; +13 : ( 14 ) idiv r8 ; +14 : ( 15 ) mov r1, eax ; +15 : ( 16 ) mov eax, r1 ;Write 1 +16 : ( ) call iprintLF ;Write 2 +17 : ( 18 ) add esp, 0 ;désallocation des variables locales +18 : ( 19 ) pop ebp ;restaure la valeur de ebp +19 : ( ) ret ; diff --git a/test/fg-ref/div4.fg b/test/fg-ref/div4.fg new file mode 100644 index 0000000000000000000000000000000000000000..1290454b530571b243af75450321cb41a6c32ebc --- /dev/null +++ b/test/fg-ref/div4.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 2 ; +8 : ( 9 ) mov r4, 3 ; +9 : ( 10 ) idiv r4 ; +10 : ( 11 ) mov r0, eax ; +11 : ( 12 ) mov eax, r0 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/ecrire1.fg b/test/fg-ref/ecrire1.fg new file mode 100644 index 0000000000000000000000000000000000000000..77c65e8da95708250210b31eb1a5083dd9dc9852 --- /dev/null +++ b/test/fg-ref/ecrire1.fg @@ -0,0 +1,12 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 3456 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( ) ret ; diff --git a/test/fg-ref/ecrire2.fg b/test/fg-ref/ecrire2.fg new file mode 100644 index 0000000000000000000000000000000000000000..31b3bc51036fbe8b233aef6fe324c5b34772e9ca --- /dev/null +++ b/test/fg-ref/ecrire2.fg @@ -0,0 +1,12 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 0 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( ) ret ; diff --git a/test/fg-ref/egal1.fg b/test/fg-ref/egal1.fg new file mode 100644 index 0000000000000000000000000000000000000000..c8c0ce0dc531d573cc73c280a2b1b198d23fca50 --- /dev/null +++ b/test/fg-ref/egal1.fg @@ -0,0 +1,17 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r3, 123 ;JumpIfEqual 1 +9 : ( 10 ) cmp r3, 123 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ;Write 1 +13 : ( ) call iprintLF ;Write 2 +14 : ( 15 ) add esp, 0 ;désallocation des variables locales +15 : ( 16 ) pop ebp ;restaure la valeur de ebp +16 : ( ) ret ; diff --git a/test/fg-ref/egal2.fg b/test/fg-ref/egal2.fg new file mode 100644 index 0000000000000000000000000000000000000000..4122164d5c7b174129908128a495133f8e7dd743 --- /dev/null +++ b/test/fg-ref/egal2.fg @@ -0,0 +1,17 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r3, 412 ;JumpIfEqual 1 +9 : ( 10 ) cmp r3, 34 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ;Write 1 +13 : ( ) call iprintLF ;Write 2 +14 : ( 15 ) add esp, 0 ;désallocation des variables locales +15 : ( 16 ) pop ebp ;restaure la valeur de ebp +16 : ( ) ret ; diff --git a/test/fg-ref/egal3.fg b/test/fg-ref/egal3.fg new file mode 100644 index 0000000000000000000000000000000000000000..7ceae358f33a4b1b49ca37a25012e1c8ae04f299 --- /dev/null +++ b/test/fg-ref/egal3.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 1 ;Affect +8 : ( 9 ) mov r4, 2 ;JumpIfEqual 1 +9 : ( 10 ) cmp r4, 2 ;on passe par un registre temporaire +10 : ( 11 12 ) je l1 ;JumpIfEqual 2 +11 : ( 12 ) mov r1, 0 ;Affect +12 : ( 13 ) l1 : mov r0, 1 ;Affect +13 : ( 14 ) cmp r1, 1 ;JumpIfEqual 1 +14 : ( 15 16 ) je l0 ;JumpIfEqual 2 +15 : ( 16 ) mov r0, 0 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/err5.fg b/test/fg-ref/err5.fg new file mode 100644 index 0000000000000000000000000000000000000000..be0611356e30443c121491fdfef97e270293fac5 --- /dev/null +++ b/test/fg-ref/err5.fg @@ -0,0 +1,22 @@ +0 : ( 12 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 1 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( 12 ) ret ; +12 : ( 13 ) main : push ebp ;sauvegarde la valeur de ebp +13 : ( 14 ) mov ebp, esp ;nouvelle valeur de ebp +14 : ( 15 ) sub esp, 4 ;allocation des variables locales +15 : ( 16 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +16 : ( 4 ) call f ; +17 : ( 18 ) pop r0 ;récupération de la valeur de retour +18 : ( 19 ) mov dword [ebp-4*1], r0 ;Affect +19 : ( 20 ) add esp, 4 ;désallocation des variables locales +20 : ( 21 ) pop ebp ;restaure la valeur de ebp +21 : ( ) ret ; diff --git a/test/fg-ref/fibo.fg b/test/fg-ref/fibo.fg new file mode 100644 index 0000000000000000000000000000000000000000..70c1ca0a2c54d771ef9cab630d10f0fc368bedcc --- /dev/null +++ b/test/fg-ref/fibo.fg @@ -0,0 +1,80 @@ +0 : ( 1 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +1 : ( 2 ) call main ; +2 : ( 3 ) pop r0 ;récupération de la valeur de retour +3 : ( 4 ) mov ebx, 0 ; valeur de retour du programme +4 : ( 5 ) mov eax, 1 ; code de sortie +5 : ( 6 ) int 0x80 ; +6 : ( 7 ) fibo : push ebp ;sauvegarde la valeur de ebp +7 : ( 8 ) mov ebp, esp ;nouvelle valeur de ebp +8 : ( 9 ) push eax ;sauvegarde de eax +9 : ( 10 ) push ebx ;sauvegarde de ebx +10 : ( 11 ) push ecx ;sauvegarde de ecx +11 : ( 12 ) push edx ;sauvegarde de edx +12 : ( 13 ) sub esp, 0 ;allocation des variables locales +13 : ( 14 ) mov r1, 1 ;Affect +14 : ( 15 ) cmp dword [ebp+12], 2 ;JumpIfLess 1 +15 : ( 16 17 ) jl l2 ;JumpIfLess 2 +16 : ( 17 ) mov r1, 0 ;Affect +17 : ( 18 ) l2 : cmp r1, 0 ;JumpIfEqual 1 +18 : ( 19 28 ) je l0 ;JumpIfEqual 2 +19 : ( 20 ) mov dword [ebp+8], 1 ;ecriture de la valeur de retour +20 : ( 21 ) add esp, 0 ;désallocation des variables locales +21 : ( 22 ) pop edx ;restaure edx +22 : ( 23 ) pop ecx ;restaure ecx +23 : ( 24 ) pop ebx ;restaure ebx +24 : ( 25 ) pop eax ;restaure eax +25 : ( 26 ) pop ebp ;restaure la valeur de ebp +26 : ( ) ret ; +27 : ( 52 ) jmp l1 ;Jump +28 : ( 29 ) l0 : mov r3, dword [ebp+12] ; +29 : ( 30 ) sub r3, 1 ; +30 : ( 31 ) push r3 ;Param +31 : ( 32 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +32 : ( 33 ) call fibo ; +33 : ( 34 ) pop r2 ;récupération de la valeur de retour +34 : ( 35 ) add esp, 4 ;désallocation des arguments +35 : ( 36 ) mov r5, dword [ebp+12] ; +36 : ( 37 ) sub r5, 2 ; +37 : ( 38 ) push r5 ;Param +38 : ( 39 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +39 : ( 40 ) call fibo ; +40 : ( 41 ) pop r4 ;récupération de la valeur de retour +41 : ( 42 ) add esp, 4 ;désallocation des arguments +42 : ( 43 ) mov r6, r2 ; +43 : ( 44 ) add r6, r4 ; +44 : ( 45 ) mov dword [ebp+8], r6 ;ecriture de la valeur de retour +45 : ( 46 ) add esp, 0 ;désallocation des variables locales +46 : ( 47 ) pop edx ;restaure edx +47 : ( 48 ) pop ecx ;restaure ecx +48 : ( 49 ) pop ebx ;restaure ebx +49 : ( 50 ) pop eax ;restaure eax +50 : ( 51 ) pop ebp ;restaure la valeur de ebp +51 : ( ) ret ; +52 : ( 53 ) l1 : add esp, 0 ;désallocation des variables locales +53 : ( 54 ) pop edx ;restaure edx +54 : ( 55 ) pop ecx ;restaure ecx +55 : ( 56 ) pop ebx ;restaure ebx +56 : ( 57 ) pop eax ;restaure eax +57 : ( 58 ) pop ebp ;restaure la valeur de ebp +58 : ( ) ret ; +59 : ( 60 ) main : push ebp ;sauvegarde la valeur de ebp +60 : ( 61 ) mov ebp, esp ;nouvelle valeur de ebp +61 : ( 62 ) push eax ;sauvegarde de eax +62 : ( 63 ) push ebx ;sauvegarde de ebx +63 : ( 64 ) push ecx ;sauvegarde de ecx +64 : ( 65 ) push edx ;sauvegarde de edx +65 : ( 66 ) sub esp, 0 ;allocation des variables locales +66 : ( 67 ) push 9 ;Param +67 : ( 68 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +68 : ( 69 ) call fibo ; +69 : ( 70 ) pop r7 ;récupération de la valeur de retour +70 : ( 71 ) add esp, 4 ;désallocation des arguments +71 : ( 72 ) mov eax, r7 ;Write 1 +72 : ( 73 ) call iprintLF ;Write 2 +73 : ( 74 ) add esp, 0 ;désallocation des variables locales +74 : ( 75 ) pop edx ;restaure edx +75 : ( 76 ) pop ecx ;restaure ecx +76 : ( 77 ) pop ebx ;restaure ebx +77 : ( 78 ) pop eax ;restaure eax +78 : ( 79 ) pop ebp ;restaure la valeur de ebp +79 : ( ) ret ; diff --git a/test/fg-ref/inf1.fg b/test/fg-ref/inf1.fg new file mode 100644 index 0000000000000000000000000000000000000000..3b96a9b590a16b4a6bc0e08ee098ac2a24cd2f5f --- /dev/null +++ b/test/fg-ref/inf1.fg @@ -0,0 +1,17 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r3, 3 ;JumpIfLess 1 +9 : ( 10 ) cmp r3, 3 ;on passe par un registre temporaire +10 : ( 11 12 ) jl l0 ;JumpIfLess 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ;Write 1 +13 : ( ) call iprintLF ;Write 2 +14 : ( 15 ) add esp, 0 ;désallocation des variables locales +15 : ( 16 ) pop ebp ;restaure la valeur de ebp +16 : ( ) ret ; diff --git a/test/fg-ref/inf2.fg b/test/fg-ref/inf2.fg new file mode 100644 index 0000000000000000000000000000000000000000..caaacf3a888d11e04579a4b3318c6608845b97c8 --- /dev/null +++ b/test/fg-ref/inf2.fg @@ -0,0 +1,17 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r3, 4 ;JumpIfLess 1 +9 : ( 10 ) cmp r3, 1 ;on passe par un registre temporaire +10 : ( 11 12 ) jl l0 ;JumpIfLess 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ;Write 1 +13 : ( ) call iprintLF ;Write 2 +14 : ( 15 ) add esp, 0 ;désallocation des variables locales +15 : ( 16 ) pop ebp ;restaure la valeur de ebp +16 : ( ) ret ; diff --git a/test/fg-ref/inf3.fg b/test/fg-ref/inf3.fg new file mode 100644 index 0000000000000000000000000000000000000000..22bb0d9c6d0354ca8ceb8dd70086ad6bfd6f6302 --- /dev/null +++ b/test/fg-ref/inf3.fg @@ -0,0 +1,17 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r3, 312 ;JumpIfLess 1 +9 : ( 10 ) cmp r3, 475 ;on passe par un registre temporaire +10 : ( 11 12 ) jl l0 ;JumpIfLess 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ;Write 1 +13 : ( ) call iprintLF ;Write 2 +14 : ( 15 ) add esp, 0 ;désallocation des variables locales +15 : ( 16 ) pop ebp ;restaure la valeur de ebp +16 : ( ) ret ; diff --git a/test/fg-ref/inf4.fg b/test/fg-ref/inf4.fg new file mode 100644 index 0000000000000000000000000000000000000000..3da39ecd80715d772fe05158ce89cf044cd25fec --- /dev/null +++ b/test/fg-ref/inf4.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 1 ;Affect +8 : ( 9 ) mov r4, 3 ;JumpIfLess 1 +9 : ( 10 ) cmp r4, 2 ;on passe par un registre temporaire +10 : ( 11 12 ) jl l1 ;JumpIfLess 2 +11 : ( 12 ) mov r1, 0 ;Affect +12 : ( 13 ) l1 : mov r0, 1 ;Affect +13 : ( 14 ) cmp r1, 1 ;JumpIfLess 1 +14 : ( 15 16 ) jl l0 ;JumpIfLess 2 +15 : ( 16 ) mov r0, 0 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/mult1.fg b/test/fg-ref/mult1.fg new file mode 100644 index 0000000000000000000000000000000000000000..227aefcc6309a3d041a5049dd0b492490e512a36 --- /dev/null +++ b/test/fg-ref/mult1.fg @@ -0,0 +1,14 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 2 ; +8 : ( 9 ) imul r0, 3 ; +9 : ( 10 ) mov eax, r0 ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) add esp, 0 ;désallocation des variables locales +12 : ( 13 ) pop ebp ;restaure la valeur de ebp +13 : ( ) ret ; diff --git a/test/fg-ref/mult2.fg b/test/fg-ref/mult2.fg new file mode 100644 index 0000000000000000000000000000000000000000..bc8b6a572cd54331008e439953359c254949a2e4 --- /dev/null +++ b/test/fg-ref/mult2.fg @@ -0,0 +1,14 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 0 ; +8 : ( 9 ) imul r0, 321 ; +9 : ( 10 ) mov eax, r0 ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) add esp, 0 ;désallocation des variables locales +12 : ( 13 ) pop ebp ;restaure la valeur de ebp +13 : ( ) ret ; diff --git a/test/fg-ref/mult3.fg b/test/fg-ref/mult3.fg new file mode 100644 index 0000000000000000000000000000000000000000..2e78fb659cd98a9a1f4359f3b324389de04a1515 --- /dev/null +++ b/test/fg-ref/mult3.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 3 ; +8 : ( 9 ) imul r0, 3 ; +9 : ( 10 ) mov r1, r0 ; +10 : ( 11 ) imul r1, 2 ; +11 : ( 12 ) mov eax, r1 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/not1.fg b/test/fg-ref/not1.fg new file mode 100644 index 0000000000000000000000000000000000000000..7b67cd6a316daf71aa6f6a3f29f36786605de0c8 --- /dev/null +++ b/test/fg-ref/not1.fg @@ -0,0 +1,17 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r3, 312 ;JumpIfEqual 1 +9 : ( 10 ) cmp r3, 0 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ;Write 1 +13 : ( ) call iprintLF ;Write 2 +14 : ( 15 ) add esp, 0 ;désallocation des variables locales +15 : ( 16 ) pop ebp ;restaure la valeur de ebp +16 : ( ) ret ; diff --git a/test/fg-ref/not2.fg b/test/fg-ref/not2.fg new file mode 100644 index 0000000000000000000000000000000000000000..6b7e91125a8953ac72f94b8a5069446fc61c12da --- /dev/null +++ b/test/fg-ref/not2.fg @@ -0,0 +1,17 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r3, 0 ;JumpIfEqual 1 +9 : ( 10 ) cmp r3, 0 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ;Write 1 +13 : ( ) call iprintLF ;Write 2 +14 : ( 15 ) add esp, 0 ;désallocation des variables locales +15 : ( 16 ) pop ebp ;restaure la valeur de ebp +16 : ( ) ret ; diff --git a/test/fg-ref/not3.fg b/test/fg-ref/not3.fg new file mode 100644 index 0000000000000000000000000000000000000000..a2d3434d504d27f07fbe091e6b2047f448a45306 --- /dev/null +++ b/test/fg-ref/not3.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 1 ;Affect +8 : ( 9 ) mov r4, 0 ;JumpIfEqual 1 +9 : ( 10 ) cmp r4, 0 ;on passe par un registre temporaire +10 : ( 11 12 ) je l1 ;JumpIfEqual 2 +11 : ( 12 ) mov r1, 0 ;Affect +12 : ( 13 ) l1 : mov r0, 1 ;Affect +13 : ( 14 ) cmp r1, 0 ;JumpIfEqual 1 +14 : ( 15 16 ) je l0 ;JumpIfEqual 2 +15 : ( 16 ) mov r0, 0 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/or1.fg b/test/fg-ref/or1.fg new file mode 100644 index 0000000000000000000000000000000000000000..d5799f4ca475680639f5c7299f5d585910941ab3 --- /dev/null +++ b/test/fg-ref/or1.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 1 ;jumpIfNotEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) jne l1 ;jumpIfNotEqual 2 +10 : ( 11 ) mov r4, 1 ;jumpIfNotEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) jne l1 ;jumpIfNotEqual 2 +13 : ( 14 ) mov r0, 0 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 1 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/or2.fg b/test/fg-ref/or2.fg new file mode 100644 index 0000000000000000000000000000000000000000..e56cdf04fc4550e62ba738f5794ef2b947600b48 --- /dev/null +++ b/test/fg-ref/or2.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 1 ;jumpIfNotEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) jne l1 ;jumpIfNotEqual 2 +10 : ( 11 ) mov r4, 0 ;jumpIfNotEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) jne l1 ;jumpIfNotEqual 2 +13 : ( 14 ) mov r0, 0 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 1 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/or3.fg b/test/fg-ref/or3.fg new file mode 100644 index 0000000000000000000000000000000000000000..f045f74b20842f4707d1e6ef3282af2b74926f98 --- /dev/null +++ b/test/fg-ref/or3.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 0 ;jumpIfNotEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) jne l1 ;jumpIfNotEqual 2 +10 : ( 11 ) mov r4, 315 ;jumpIfNotEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) jne l1 ;jumpIfNotEqual 2 +13 : ( 14 ) mov r0, 0 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 1 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/or4.fg b/test/fg-ref/or4.fg new file mode 100644 index 0000000000000000000000000000000000000000..f55660b5de239ad5156e7435d5f9cb69b7c3ad22 --- /dev/null +++ b/test/fg-ref/or4.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 0 ;jumpIfNotEqual 1 +8 : ( 9 ) cmp r3, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) jne l1 ;jumpIfNotEqual 2 +10 : ( 11 ) mov r4, 0 ;jumpIfNotEqual 1 +11 : ( 12 ) cmp r4, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) jne l1 ;jumpIfNotEqual 2 +13 : ( 14 ) mov r0, 0 ;Affect +14 : ( 16 ) jmp l0 ;Jump +15 : ( 16 ) l1 : mov r0, 1 ;Affect +16 : ( 17 ) l0 : mov eax, r0 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/or5.fg b/test/fg-ref/or5.fg new file mode 100644 index 0000000000000000000000000000000000000000..a374a43dd26735a3a6c42f3df6d74b422c69907c --- /dev/null +++ b/test/fg-ref/or5.fg @@ -0,0 +1,29 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r4, 0 ;jumpIfNotEqual 1 +8 : ( 9 ) cmp r4, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) jne l3 ;jumpIfNotEqual 2 +10 : ( 11 ) mov r5, 1 ;jumpIfNotEqual 1 +11 : ( 12 ) cmp r5, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) jne l3 ;jumpIfNotEqual 2 +13 : ( 14 ) mov r1, 0 ;Affect +14 : ( 16 ) jmp l2 ;Jump +15 : ( 16 ) l3 : mov r1, 1 ;Affect +16 : ( 17 ) l2 : cmp r1, 0 ;jumpIfNotEqual 1 +17 : ( 18 23 ) jne l1 ;jumpIfNotEqual 2 +18 : ( 19 ) mov r6, 0 ;jumpIfNotEqual 1 +19 : ( 20 ) cmp r6, 0 ;on passe par un registre temporaire +20 : ( 21 23 ) jne l1 ;jumpIfNotEqual 2 +21 : ( 22 ) mov r0, 0 ;Affect +22 : ( 24 ) jmp l0 ;Jump +23 : ( 24 ) l1 : mov r0, 1 ;Affect +24 : ( 25 ) l0 : mov eax, r0 ;Write 1 +25 : ( ) call iprintLF ;Write 2 +26 : ( 27 ) add esp, 0 ;désallocation des variables locales +27 : ( 28 ) pop ebp ;restaure la valeur de ebp +28 : ( ) ret ; diff --git a/test/fg-ref/parenth1.fg b/test/fg-ref/parenth1.fg new file mode 100644 index 0000000000000000000000000000000000000000..cae97fc1354646dfb64d5ca7460215d8355867cf --- /dev/null +++ b/test/fg-ref/parenth1.fg @@ -0,0 +1,12 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 1 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( ) ret ; diff --git a/test/fg-ref/parenth2.fg b/test/fg-ref/parenth2.fg new file mode 100644 index 0000000000000000000000000000000000000000..11ce3211ad1ff2160e28224e052aafe9647540d3 --- /dev/null +++ b/test/fg-ref/parenth2.fg @@ -0,0 +1,12 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 2 ;Write 1 +8 : ( ) call iprintLF ;Write 2 +9 : ( 10 ) add esp, 0 ;désallocation des variables locales +10 : ( 11 ) pop ebp ;restaure la valeur de ebp +11 : ( ) ret ; diff --git a/test/fg-ref/prio23-1.fg b/test/fg-ref/prio23-1.fg new file mode 100644 index 0000000000000000000000000000000000000000..64a231603f13999c7ede7c1b4118b7805f6e029b --- /dev/null +++ b/test/fg-ref/prio23-1.fg @@ -0,0 +1,19 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r4, 0 ;JumpIfEqual 1 +9 : ( 10 ) cmp r4, 0 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov r1, r0 ; +13 : ( 14 ) imul r1, 10 ; +14 : ( 15 ) mov eax, r1 ;Write 1 +15 : ( ) call iprintLF ;Write 2 +16 : ( 17 ) add esp, 0 ;désallocation des variables locales +17 : ( 18 ) pop ebp ;restaure la valeur de ebp +18 : ( ) ret ; diff --git a/test/fg-ref/prio23-2.fg b/test/fg-ref/prio23-2.fg new file mode 100644 index 0000000000000000000000000000000000000000..40ad4e9a6db3bdf2c4e589888dccf811fbbd2294 --- /dev/null +++ b/test/fg-ref/prio23-2.fg @@ -0,0 +1,19 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r4, 10 ;JumpIfEqual 1 +9 : ( 10 ) cmp r4, 0 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov r1, 3 ; +13 : ( 14 ) imul r1, r0 ; +14 : ( 15 ) mov eax, r1 ;Write 1 +15 : ( ) call iprintLF ;Write 2 +16 : ( 17 ) add esp, 0 ;désallocation des variables locales +17 : ( 18 ) pop ebp ;restaure la valeur de ebp +18 : ( ) ret ; diff --git a/test/fg-ref/prio23-3.fg b/test/fg-ref/prio23-3.fg new file mode 100644 index 0000000000000000000000000000000000000000..b816b703a80139ed48df8db2a877be2f5d5395b3 --- /dev/null +++ b/test/fg-ref/prio23-3.fg @@ -0,0 +1,21 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r4, 0 ;JumpIfEqual 1 +9 : ( 10 ) cmp r4, 0 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov eax, r0 ; +13 : ( 14 ) mov r6, 1 ; +14 : ( 15 ) idiv r6 ; +15 : ( 16 ) mov r1, eax ; +16 : ( 17 ) mov eax, r1 ;Write 1 +17 : ( ) call iprintLF ;Write 2 +18 : ( 19 ) add esp, 0 ;désallocation des variables locales +19 : ( 20 ) pop ebp ;restaure la valeur de ebp +20 : ( ) ret ; diff --git a/test/fg-ref/prio23-4.fg b/test/fg-ref/prio23-4.fg new file mode 100644 index 0000000000000000000000000000000000000000..08cb33a7ebbf61fc4c4d73fb763d6e3036d5a658 --- /dev/null +++ b/test/fg-ref/prio23-4.fg @@ -0,0 +1,25 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 1 ;Affect +8 : ( 9 ) mov r5, 1 ;JumpIfEqual 1 +9 : ( 10 ) cmp r5, 0 ;on passe par un registre temporaire +10 : ( 11 12 ) je l0 ;JumpIfEqual 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l0 : mov r1, 1 ;Affect +13 : ( 14 ) mov r6, 0 ;JumpIfEqual 1 +14 : ( 15 ) cmp r6, 0 ;on passe par un registre temporaire +15 : ( 16 17 ) je l1 ;JumpIfEqual 2 +16 : ( 17 ) mov r1, 0 ;Affect +17 : ( 18 ) l1 : mov eax, r0 ; +18 : ( 19 ) idiv r1 ; +19 : ( 20 ) mov r2, eax ; +20 : ( 21 ) mov eax, r2 ;Write 1 +21 : ( ) call iprintLF ;Write 2 +22 : ( 23 ) add esp, 0 ;désallocation des variables locales +23 : ( 24 ) pop ebp ;restaure la valeur de ebp +24 : ( ) ret ; diff --git a/test/fg-ref/prio34-1.fg b/test/fg-ref/prio34-1.fg new file mode 100644 index 0000000000000000000000000000000000000000..9eeb40e66c40de5e1fc6dd43937e79c2174bb19c --- /dev/null +++ b/test/fg-ref/prio34-1.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 3 ; +8 : ( 9 ) imul r0, 4 ; +9 : ( 10 ) mov r1, 2 ; +10 : ( 11 ) add r1, r0 ; +11 : ( 12 ) mov eax, r1 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/prio34-2.fg b/test/fg-ref/prio34-2.fg new file mode 100644 index 0000000000000000000000000000000000000000..fb9014447bff969e3614644d9b14e01f9a856858 --- /dev/null +++ b/test/fg-ref/prio34-2.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 2 ; +8 : ( 9 ) imul r0, 3 ; +9 : ( 10 ) mov r1, r0 ; +10 : ( 11 ) sub r1, 4 ; +11 : ( 12 ) mov eax, r1 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/prio34-3.fg b/test/fg-ref/prio34-3.fg new file mode 100644 index 0000000000000000000000000000000000000000..9c8c152734da0230e05601420830a0a1eae85377 --- /dev/null +++ b/test/fg-ref/prio34-3.fg @@ -0,0 +1,18 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 6 ; +8 : ( 9 ) mov r5, 3 ; +9 : ( 10 ) idiv r5 ; +10 : ( 11 ) mov r0, eax ; +11 : ( 12 ) mov r1, r0 ; +12 : ( 13 ) sub r1, 72 ; +13 : ( 14 ) mov eax, r1 ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) add esp, 0 ;désallocation des variables locales +16 : ( 17 ) pop ebp ;restaure la valeur de ebp +17 : ( ) ret ; diff --git a/test/fg-ref/prio34-4.fg b/test/fg-ref/prio34-4.fg new file mode 100644 index 0000000000000000000000000000000000000000..9f93a0086765c41cfafeb28f2490e5701aaf71c4 --- /dev/null +++ b/test/fg-ref/prio34-4.fg @@ -0,0 +1,18 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov eax, 20 ; +8 : ( 9 ) mov r5, 10 ; +9 : ( 10 ) idiv r5 ; +10 : ( 11 ) mov r0, eax ; +11 : ( 12 ) mov r1, 6 ; +12 : ( 13 ) add r1, r0 ; +13 : ( 14 ) mov eax, r1 ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) add esp, 0 ;désallocation des variables locales +16 : ( 17 ) pop ebp ;restaure la valeur de ebp +17 : ( ) ret ; diff --git a/test/fg-ref/prio45-1.fg b/test/fg-ref/prio45-1.fg new file mode 100644 index 0000000000000000000000000000000000000000..d74cf0c856d5be0aa8dee349cce4ff660a5288b8 --- /dev/null +++ b/test/fg-ref/prio45-1.fg @@ -0,0 +1,19 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 0 ; +8 : ( 9 ) add r1, 1 ; +9 : ( 10 ) mov r0, 1 ;Affect +10 : ( 11 ) mov r4, 2 ;JumpIfEqual 1 +11 : ( 12 ) cmp r4, r1 ;on passe par un registre temporaire +12 : ( 13 14 ) je l0 ;JumpIfEqual 2 +13 : ( 14 ) mov r0, 0 ;Affect +14 : ( 15 ) l0 : mov eax, r0 ;Write 1 +15 : ( ) call iprintLF ;Write 2 +16 : ( 17 ) add esp, 0 ;désallocation des variables locales +17 : ( 18 ) pop ebp ;restaure la valeur de ebp +18 : ( ) ret ; diff --git a/test/fg-ref/prio45-2.fg b/test/fg-ref/prio45-2.fg new file mode 100644 index 0000000000000000000000000000000000000000..296352a080b5edcdc9a094a021b1132d7a321478 --- /dev/null +++ b/test/fg-ref/prio45-2.fg @@ -0,0 +1,18 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 1 ; +8 : ( 9 ) add r1, 234 ; +9 : ( 10 ) mov r0, 1 ;Affect +10 : ( 11 ) cmp r1, 1 ;JumpIfEqual 1 +11 : ( 12 13 ) je l0 ;JumpIfEqual 2 +12 : ( 13 ) mov r0, 0 ;Affect +13 : ( 14 ) l0 : mov eax, r0 ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) add esp, 0 ;désallocation des variables locales +16 : ( 17 ) pop ebp ;restaure la valeur de ebp +17 : ( ) ret ; diff --git a/test/fg-ref/prio45-3.fg b/test/fg-ref/prio45-3.fg new file mode 100644 index 0000000000000000000000000000000000000000..3d0b5347d9d21be9d2100cba6f2fd4902b948751 --- /dev/null +++ b/test/fg-ref/prio45-3.fg @@ -0,0 +1,19 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 11 ; +8 : ( 9 ) add r1, 100 ; +9 : ( 10 ) mov r0, 1 ;Affect +10 : ( 11 ) mov r4, 12 ;JumpIfLess 1 +11 : ( 12 ) cmp r4, r1 ;on passe par un registre temporaire +12 : ( 13 14 ) jl l0 ;JumpIfLess 2 +13 : ( 14 ) mov r0, 0 ;Affect +14 : ( 15 ) l0 : mov eax, r0 ;Write 1 +15 : ( ) call iprintLF ;Write 2 +16 : ( 17 ) add esp, 0 ;désallocation des variables locales +17 : ( 18 ) pop ebp ;restaure la valeur de ebp +18 : ( ) ret ; diff --git a/test/fg-ref/prio45-4.fg b/test/fg-ref/prio45-4.fg new file mode 100644 index 0000000000000000000000000000000000000000..9374e20bc759f442f0e58e6b8473f9b8b6a20a78 --- /dev/null +++ b/test/fg-ref/prio45-4.fg @@ -0,0 +1,18 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 21 ; +8 : ( 9 ) sub r1, 21 ; +9 : ( 10 ) mov r0, 1 ;Affect +10 : ( 11 ) cmp r1, 1 ;JumpIfLess 1 +11 : ( 12 13 ) jl l0 ;JumpIfLess 2 +12 : ( 13 ) mov r0, 0 ;Affect +13 : ( 14 ) l0 : mov eax, r0 ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) add esp, 0 ;désallocation des variables locales +16 : ( 17 ) pop ebp ;restaure la valeur de ebp +17 : ( ) ret ; diff --git a/test/fg-ref/prio56-1.fg b/test/fg-ref/prio56-1.fg new file mode 100644 index 0000000000000000000000000000000000000000..52cb8267443ef1803c8eff595649ed80655a7b97 --- /dev/null +++ b/test/fg-ref/prio56-1.fg @@ -0,0 +1,25 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 1 ;Affect +8 : ( 9 ) mov r4, 1 ;JumpIfEqual 1 +9 : ( 10 ) cmp r4, 2 ;on passe par un registre temporaire +10 : ( 11 12 ) je l2 ;JumpIfEqual 2 +11 : ( 12 ) mov r1, 0 ;Affect +12 : ( 13 ) l2 : cmp r1, 0 ;JumpIfEqual 1 +13 : ( 14 19 ) je l1 ;JumpIfEqual 2 +14 : ( 15 ) mov r5, 1 ;JumpIfEqual 1 +15 : ( 16 ) cmp r5, 0 ;on passe par un registre temporaire +16 : ( 17 19 ) je l1 ;JumpIfEqual 2 +17 : ( 18 ) mov r0, 1 ;Affect +18 : ( 20 ) jmp l0 ;Jump +19 : ( 20 ) l1 : mov r0, 0 ;Affect +20 : ( 21 ) l0 : mov eax, r0 ;Write 1 +21 : ( ) call iprintLF ;Write 2 +22 : ( 23 ) add esp, 0 ;désallocation des variables locales +23 : ( 24 ) pop ebp ;restaure la valeur de ebp +24 : ( ) ret ; diff --git a/test/fg-ref/prio56-2.fg b/test/fg-ref/prio56-2.fg new file mode 100644 index 0000000000000000000000000000000000000000..bf9bdabae21c4918132d25b3c3919e60bd3e1bb6 --- /dev/null +++ b/test/fg-ref/prio56-2.fg @@ -0,0 +1,25 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r1, 1 ;Affect +8 : ( 9 ) mov r4, 2 ;JumpIfEqual 1 +9 : ( 10 ) cmp r4, 1 ;on passe par un registre temporaire +10 : ( 11 12 ) je l2 ;JumpIfEqual 2 +11 : ( 12 ) mov r1, 0 ;Affect +12 : ( 13 ) l2 : mov r5, 1 ;JumpIfEqual 1 +13 : ( 14 ) cmp r5, 0 ;on passe par un registre temporaire +14 : ( 15 19 ) je l1 ;JumpIfEqual 2 +15 : ( 16 ) cmp r1, 0 ;JumpIfEqual 1 +16 : ( 17 19 ) je l1 ;JumpIfEqual 2 +17 : ( 18 ) mov r0, 1 ;Affect +18 : ( 20 ) jmp l0 ;Jump +19 : ( 20 ) l1 : mov r0, 0 ;Affect +20 : ( 21 ) l0 : mov eax, r0 ;Write 1 +21 : ( ) call iprintLF ;Write 2 +22 : ( 23 ) add esp, 0 ;désallocation des variables locales +23 : ( 24 ) pop ebp ;restaure la valeur de ebp +24 : ( ) ret ; diff --git a/test/fg-ref/prio67-1.fg b/test/fg-ref/prio67-1.fg new file mode 100644 index 0000000000000000000000000000000000000000..f7a44e62a3d634d4f6a4c004273a69ba1698c49d --- /dev/null +++ b/test/fg-ref/prio67-1.fg @@ -0,0 +1,29 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r4, 0 ;JumpIfEqual 1 +8 : ( 9 ) cmp r4, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) je l3 ;JumpIfEqual 2 +10 : ( 11 ) mov r5, 1 ;JumpIfEqual 1 +11 : ( 12 ) cmp r5, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) je l3 ;JumpIfEqual 2 +13 : ( 14 ) mov r1, 1 ;Affect +14 : ( 16 ) jmp l2 ;Jump +15 : ( 16 ) l3 : mov r1, 0 ;Affect +16 : ( 17 ) l2 : cmp r1, 0 ;jumpIfNotEqual 1 +17 : ( 18 23 ) jne l1 ;jumpIfNotEqual 2 +18 : ( 19 ) mov r6, 1 ;jumpIfNotEqual 1 +19 : ( 20 ) cmp r6, 0 ;on passe par un registre temporaire +20 : ( 21 23 ) jne l1 ;jumpIfNotEqual 2 +21 : ( 22 ) mov r0, 0 ;Affect +22 : ( 24 ) jmp l0 ;Jump +23 : ( 24 ) l1 : mov r0, 1 ;Affect +24 : ( 25 ) l0 : mov eax, r0 ;Write 1 +25 : ( ) call iprintLF ;Write 2 +26 : ( 27 ) add esp, 0 ;désallocation des variables locales +27 : ( 28 ) pop ebp ;restaure la valeur de ebp +28 : ( ) ret ; diff --git a/test/fg-ref/prio67-2.fg b/test/fg-ref/prio67-2.fg new file mode 100644 index 0000000000000000000000000000000000000000..2d932b72f1dc60d06447706b4032f65eec555ddc --- /dev/null +++ b/test/fg-ref/prio67-2.fg @@ -0,0 +1,29 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r4, 1 ;JumpIfEqual 1 +8 : ( 9 ) cmp r4, 0 ;on passe par un registre temporaire +9 : ( 10 15 ) je l3 ;JumpIfEqual 2 +10 : ( 11 ) mov r5, 0 ;JumpIfEqual 1 +11 : ( 12 ) cmp r5, 0 ;on passe par un registre temporaire +12 : ( 13 15 ) je l3 ;JumpIfEqual 2 +13 : ( 14 ) mov r1, 1 ;Affect +14 : ( 16 ) jmp l2 ;Jump +15 : ( 16 ) l3 : mov r1, 0 ;Affect +16 : ( 17 ) l2 : mov r6, 1 ;jumpIfNotEqual 1 +17 : ( 18 ) cmp r6, 0 ;on passe par un registre temporaire +18 : ( 19 23 ) jne l1 ;jumpIfNotEqual 2 +19 : ( 20 ) cmp r1, 0 ;jumpIfNotEqual 1 +20 : ( 21 23 ) jne l1 ;jumpIfNotEqual 2 +21 : ( 22 ) mov r0, 0 ;Affect +22 : ( 24 ) jmp l0 ;Jump +23 : ( 24 ) l1 : mov r0, 1 ;Affect +24 : ( 25 ) l0 : mov eax, r0 ;Write 1 +25 : ( ) call iprintLF ;Write 2 +26 : ( 27 ) add esp, 0 ;désallocation des variables locales +27 : ( 28 ) pop ebp ;restaure la valeur de ebp +28 : ( ) ret ; diff --git a/test/fg-ref/rec1.fg b/test/fg-ref/rec1.fg new file mode 100644 index 0000000000000000000000000000000000000000..755d8ec25bcc5d83855e2bbf6952da6e07c8cbb8 --- /dev/null +++ b/test/fg-ref/rec1.fg @@ -0,0 +1,73 @@ +0 : ( 1 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +1 : ( 2 ) call main ; +2 : ( 3 ) pop r0 ;récupération de la valeur de retour +3 : ( 4 ) mov ebx, 0 ; valeur de retour du programme +4 : ( 5 ) mov eax, 1 ; code de sortie +5 : ( 6 ) int 0x80 ; +6 : ( 7 ) f : push ebp ;sauvegarde la valeur de ebp +7 : ( 8 ) mov ebp, esp ;nouvelle valeur de ebp +8 : ( 9 ) push eax ;sauvegarde de eax +9 : ( 10 ) push ebx ;sauvegarde de ebx +10 : ( 11 ) push ecx ;sauvegarde de ecx +11 : ( 12 ) push edx ;sauvegarde de edx +12 : ( 13 ) sub esp, 0 ;allocation des variables locales +13 : ( 14 ) mov r1, 1 ;Affect +14 : ( 15 ) cmp dword [ebp+12], 1 ;JumpIfEqual 1 +15 : ( 16 17 ) je l2 ;JumpIfEqual 2 +16 : ( 17 ) mov r1, 0 ;Affect +17 : ( 18 ) l2 : cmp r1, 0 ;JumpIfEqual 1 +18 : ( 19 28 ) je l0 ;JumpIfEqual 2 +19 : ( 20 ) mov dword [ebp+8], 1 ;ecriture de la valeur de retour +20 : ( 21 ) add esp, 0 ;désallocation des variables locales +21 : ( 22 ) pop edx ;restaure edx +22 : ( 23 ) pop ecx ;restaure ecx +23 : ( 24 ) pop ebx ;restaure ebx +24 : ( 25 ) pop eax ;restaure eax +25 : ( 26 ) pop ebp ;restaure la valeur de ebp +26 : ( ) ret ; +27 : ( 45 ) jmp l1 ;Jump +28 : ( 29 ) l0 : mov r3, dword [ebp+12] ; +29 : ( 30 ) sub r3, 1 ; +30 : ( 31 ) push r3 ;Param +31 : ( 32 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +32 : ( 33 ) call f ; +33 : ( 34 ) pop r2 ;récupération de la valeur de retour +34 : ( 35 ) add esp, 4 ;désallocation des arguments +35 : ( 36 ) mov r4, 1 ; +36 : ( 37 ) add r4, r2 ; +37 : ( 38 ) mov dword [ebp+8], r4 ;ecriture de la valeur de retour +38 : ( 39 ) add esp, 0 ;désallocation des variables locales +39 : ( 40 ) pop edx ;restaure edx +40 : ( 41 ) pop ecx ;restaure ecx +41 : ( 42 ) pop ebx ;restaure ebx +42 : ( 43 ) pop eax ;restaure eax +43 : ( 44 ) pop ebp ;restaure la valeur de ebp +44 : ( ) ret ; +45 : ( 46 ) l1 : add esp, 0 ;désallocation des variables locales +46 : ( 47 ) pop edx ;restaure edx +47 : ( 48 ) pop ecx ;restaure ecx +48 : ( 49 ) pop ebx ;restaure ebx +49 : ( 50 ) pop eax ;restaure eax +50 : ( 51 ) pop ebp ;restaure la valeur de ebp +51 : ( ) ret ; +52 : ( 53 ) main : push ebp ;sauvegarde la valeur de ebp +53 : ( 54 ) mov ebp, esp ;nouvelle valeur de ebp +54 : ( 55 ) push eax ;sauvegarde de eax +55 : ( 56 ) push ebx ;sauvegarde de ebx +56 : ( 57 ) push ecx ;sauvegarde de ecx +57 : ( 58 ) push edx ;sauvegarde de edx +58 : ( 59 ) sub esp, 0 ;allocation des variables locales +59 : ( 60 ) push 100 ;Param +60 : ( 61 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +61 : ( 62 ) call f ; +62 : ( 63 ) pop r5 ;récupération de la valeur de retour +63 : ( 64 ) add esp, 4 ;désallocation des arguments +64 : ( 65 ) mov eax, r5 ;Write 1 +65 : ( 66 ) call iprintLF ;Write 2 +66 : ( 67 ) add esp, 0 ;désallocation des variables locales +67 : ( 68 ) pop edx ;restaure edx +68 : ( 69 ) pop ecx ;restaure ecx +69 : ( 70 ) pop ebx ;restaure ebx +70 : ( 71 ) pop eax ;restaure eax +71 : ( 72 ) pop ebp ;restaure la valeur de ebp +72 : ( ) ret ; diff --git a/test/fg-ref/si1.fg b/test/fg-ref/si1.fg new file mode 100644 index 0000000000000000000000000000000000000000..d613104da641d3cfe4eb9d712cd22257f85ffbe1 --- /dev/null +++ b/test/fg-ref/si1.fg @@ -0,0 +1,15 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r2, 1 ;JumpIfEqual 1 +8 : ( 9 ) cmp r2, 0 ;on passe par un registre temporaire +9 : ( 10 12 ) je l1 ;JumpIfEqual 2 +10 : ( 11 ) mov eax, 1 ;Write 1 +11 : ( ) call iprintLF ;Write 2 +12 : ( 13 ) l1 : add esp, 0 ;désallocation des variables locales +13 : ( 14 ) pop ebp ;restaure la valeur de ebp +14 : ( ) ret ; diff --git a/test/fg-ref/si2.fg b/test/fg-ref/si2.fg new file mode 100644 index 0000000000000000000000000000000000000000..80160c1b2fd3c49220ff80ddb5fc0aadf930ed83 --- /dev/null +++ b/test/fg-ref/si2.fg @@ -0,0 +1,18 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r2, 0 ;JumpIfEqual 1 +8 : ( 9 ) cmp r2, 0 ;on passe par un registre temporaire +9 : ( 10 13 ) je l0 ;JumpIfEqual 2 +10 : ( 11 ) mov eax, 1 ;Write 1 +11 : ( ) call iprintLF ;Write 2 +12 : ( 15 ) jmp l1 ;Jump +13 : ( 14 ) l0 : mov eax, 0 ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) l1 : add esp, 0 ;désallocation des variables locales +16 : ( 17 ) pop ebp ;restaure la valeur de ebp +17 : ( ) ret ; diff --git a/test/fg-ref/si3.fg b/test/fg-ref/si3.fg new file mode 100644 index 0000000000000000000000000000000000000000..4a590860501d840bade594a94eb86574fb2cb462 --- /dev/null +++ b/test/fg-ref/si3.fg @@ -0,0 +1,20 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r2, 1 ;JumpIfEqual 1 +8 : ( 9 ) cmp r2, 0 ;on passe par un registre temporaire +9 : ( 10 13 ) je l0 ;JumpIfEqual 2 +10 : ( 11 ) mov eax, 1 ;Write 1 +11 : ( ) call iprintLF ;Write 2 +12 : ( 15 ) jmp l1 ;Jump +13 : ( 14 ) l0 : mov eax, 0 ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) l1 : mov eax, 3 ;Write 1 +16 : ( ) call iprintLF ;Write 2 +17 : ( 18 ) add esp, 0 ;désallocation des variables locales +18 : ( 19 ) pop ebp ;restaure la valeur de ebp +19 : ( ) ret ; diff --git a/test/fg-ref/si4.fg b/test/fg-ref/si4.fg new file mode 100644 index 0000000000000000000000000000000000000000..887ca3711058d0a8ae654c0b22de7d3a12feb41d --- /dev/null +++ b/test/fg-ref/si4.fg @@ -0,0 +1,20 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r2, 0 ;JumpIfEqual 1 +8 : ( 9 ) cmp r2, 0 ;on passe par un registre temporaire +9 : ( 10 13 ) je l0 ;JumpIfEqual 2 +10 : ( 11 ) mov eax, 1 ;Write 1 +11 : ( ) call iprintLF ;Write 2 +12 : ( 15 ) jmp l1 ;Jump +13 : ( 14 ) l0 : mov eax, 0 ;Write 1 +14 : ( ) call iprintLF ;Write 2 +15 : ( 16 ) l1 : mov eax, 3 ;Write 1 +16 : ( ) call iprintLF ;Write 2 +17 : ( 18 ) add esp, 0 ;désallocation des variables locales +18 : ( 19 ) pop ebp ;restaure la valeur de ebp +19 : ( ) ret ; diff --git a/test/fg-ref/si5.fg b/test/fg-ref/si5.fg new file mode 100644 index 0000000000000000000000000000000000000000..db829b986885138fddca78dbc7db1eea7a62706d --- /dev/null +++ b/test/fg-ref/si5.fg @@ -0,0 +1,32 @@ +0 : ( 1 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +1 : ( 2 ) call main ; +2 : ( 3 ) pop r0 ;récupération de la valeur de retour +3 : ( 4 ) mov ebx, 0 ; valeur de retour du programme +4 : ( 5 ) mov eax, 1 ; code de sortie +5 : ( 6 ) int 0x80 ; +6 : ( 7 ) main : push ebp ;sauvegarde la valeur de ebp +7 : ( 8 ) mov ebp, esp ;nouvelle valeur de ebp +8 : ( 9 ) push eax ;sauvegarde de eax +9 : ( 10 ) push ebx ;sauvegarde de ebx +10 : ( 11 ) push ecx ;sauvegarde de ecx +11 : ( 12 ) push edx ;sauvegarde de edx +12 : ( 13 ) sub esp, 0 ;allocation des variables locales +13 : ( 14 ) mov r7, 1 ;JumpIfEqual 1 +14 : ( 15 ) cmp r7, 0 ;on passe par un registre temporaire +15 : ( 16 23 ) je l3 ;JumpIfEqual 2 +16 : ( 17 ) mov eax, 1 ;Write 1 +17 : ( 18 ) call iprintLF ;Write 2 +18 : ( 19 ) mov r9, 1 ;JumpIfEqual 1 +19 : ( 20 ) cmp r9, 0 ;on passe par un registre temporaire +20 : ( 21 23 ) je l3 ;JumpIfEqual 2 +21 : ( 22 ) mov eax, 2 ;Write 1 +22 : ( 23 ) call iprintLF ;Write 2 +23 : ( 24 ) l3 : mov eax, 3 ;Write 1 +24 : ( 25 ) call iprintLF ;Write 2 +25 : ( 26 ) add esp, 0 ;désallocation des variables locales +26 : ( 27 ) pop edx ;restaure edx +27 : ( 28 ) pop ecx ;restaure ecx +28 : ( 29 ) pop ebx ;restaure ebx +29 : ( 30 ) pop eax ;restaure eax +30 : ( 31 ) pop ebp ;restaure la valeur de ebp +31 : ( ) ret ; diff --git a/test/fg-ref/sub1.fg b/test/fg-ref/sub1.fg new file mode 100644 index 0000000000000000000000000000000000000000..e208bab202a1d40ba7fcc1db72823544eab5557d --- /dev/null +++ b/test/fg-ref/sub1.fg @@ -0,0 +1,14 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 10 ; +8 : ( 9 ) sub r0, 5 ; +9 : ( 10 ) mov eax, r0 ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) add esp, 0 ;désallocation des variables locales +12 : ( 13 ) pop ebp ;restaure la valeur de ebp +13 : ( ) ret ; diff --git a/test/fg-ref/sub2.fg b/test/fg-ref/sub2.fg new file mode 100644 index 0000000000000000000000000000000000000000..d9faa903d403252c129e7aba839bf460bedc8485 --- /dev/null +++ b/test/fg-ref/sub2.fg @@ -0,0 +1,14 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 7 ; +8 : ( 9 ) sub r0, 20 ; +9 : ( 10 ) mov eax, r0 ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) add esp, 0 ;désallocation des variables locales +12 : ( 13 ) pop ebp ;restaure la valeur de ebp +13 : ( ) ret ; diff --git a/test/fg-ref/sub3.fg b/test/fg-ref/sub3.fg new file mode 100644 index 0000000000000000000000000000000000000000..4d4b04e4377030744f7907f7298057f16c5a507d --- /dev/null +++ b/test/fg-ref/sub3.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r0, 2 ; +8 : ( 9 ) sub r0, 1 ; +9 : ( 10 ) mov r1, r0 ; +10 : ( 11 ) sub r1, 1 ; +11 : ( 12 ) mov eax, r1 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/tab1.fg b/test/fg-ref/tab1.fg new file mode 100644 index 0000000000000000000000000000000000000000..abbe0a107615f47f8f86827e7accfb087d3d8dc2 --- /dev/null +++ b/test/fg-ref/tab1.fg @@ -0,0 +1,25 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r2, 0 ; +8 : ( 9 ) mov dword [tab+4*r2], 0 ;Affect +9 : ( 10 ) mov r3, 1 ; +10 : ( 11 ) mov dword [tab+4*r3], 1 ;Affect +11 : ( 12 ) mov r4, 2 ; +12 : ( 13 ) mov dword [tab+4*r4], 2 ;Affect +13 : ( 14 ) mov r6, 0 ; +14 : ( 15 ) mov eax, dword [tab+4*r6] ;Write 1 +15 : ( ) call iprintLF ;Write 2 +16 : ( 17 ) mov r8, 1 ; +17 : ( 18 ) mov eax, dword [tab+4*r8] ;Write 1 +18 : ( ) call iprintLF ;Write 2 +19 : ( 20 ) mov r10, 2 ; +20 : ( 21 ) mov eax, dword [tab+4*r10] ;Write 1 +21 : ( ) call iprintLF ;Write 2 +22 : ( 23 ) add esp, 0 ;désallocation des variables locales +23 : ( 24 ) pop ebp ;restaure la valeur de ebp +24 : ( ) ret ; diff --git a/test/fg-ref/tab2.fg b/test/fg-ref/tab2.fg new file mode 100644 index 0000000000000000000000000000000000000000..ec815098d85d0e0ece4443b018df29389a99feb4 --- /dev/null +++ b/test/fg-ref/tab2.fg @@ -0,0 +1,32 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 4 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 2 ;Affect +8 : ( 9 ) mov r0, dword [ebp-4*1] ; +9 : ( 10 ) add r0, 0 ; +10 : ( 11 ) mov r5, r0 ; +11 : ( 12 ) mov dword [tab+4*r5], 34 ;Affect +12 : ( 13 ) mov r1, dword [ebp-4*1] ; +13 : ( 14 ) add r1, 1 ; +14 : ( 15 ) mov r6, r1 ; +15 : ( 16 ) mov dword [tab+4*r6], 74 ;Affect +16 : ( 17 ) mov r2, dword [ebp-4*1] ; +17 : ( 18 ) add r2, 2 ; +18 : ( 19 ) mov r7, r2 ; +19 : ( 20 ) mov dword [tab+4*r7], 16 ;Affect +20 : ( 21 ) mov r9, 2 ; +21 : ( 22 ) mov eax, dword [tab+4*r9] ;Write 1 +22 : ( ) call iprintLF ;Write 2 +23 : ( 24 ) mov r11, 3 ; +24 : ( 25 ) mov eax, dword [tab+4*r11] ;Write 1 +25 : ( ) call iprintLF ;Write 2 +26 : ( 27 ) mov r13, 4 ; +27 : ( 28 ) mov eax, dword [tab+4*r13] ;Write 1 +28 : ( ) call iprintLF ;Write 2 +29 : ( 30 ) add esp, 4 ;désallocation des variables locales +30 : ( 31 ) pop ebp ;restaure la valeur de ebp +31 : ( ) ret ; diff --git a/test/fg-ref/tab3.fg b/test/fg-ref/tab3.fg new file mode 100644 index 0000000000000000000000000000000000000000..fc912f651084c229398f825bc71a2552c4e51440 --- /dev/null +++ b/test/fg-ref/tab3.fg @@ -0,0 +1,35 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 8 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 2 ;Affect +8 : ( 9 ) mov dword [ebp-4*2], 0 ;Affect +9 : ( 10 ) mov r0, dword [ebp-4*1] ; +10 : ( 11 ) add r0, dword [ebp-4*2] ; +11 : ( 12 ) mov r5, r0 ; +12 : ( 13 ) mov dword [tab+4*r5], 34 ;Affect +13 : ( 14 ) mov dword [ebp-4*2], 1 ;Affect +14 : ( 15 ) mov r1, dword [ebp-4*1] ; +15 : ( 16 ) add r1, dword [ebp-4*2] ; +16 : ( 17 ) mov r6, r1 ; +17 : ( 18 ) mov dword [tab+4*r6], 74 ;Affect +18 : ( 19 ) mov dword [ebp-4*2], 2 ;Affect +19 : ( 20 ) mov r2, dword [ebp-4*1] ; +20 : ( 21 ) add r2, dword [ebp-4*2] ; +21 : ( 22 ) mov r7, r2 ; +22 : ( 23 ) mov dword [tab+4*r7], 16 ;Affect +23 : ( 24 ) mov r9, 2 ; +24 : ( 25 ) mov eax, dword [tab+4*r9] ;Write 1 +25 : ( ) call iprintLF ;Write 2 +26 : ( 27 ) mov r11, 3 ; +27 : ( 28 ) mov eax, dword [tab+4*r11] ;Write 1 +28 : ( ) call iprintLF ;Write 2 +29 : ( 30 ) mov r13, 4 ; +30 : ( 31 ) mov eax, dword [tab+4*r13] ;Write 1 +31 : ( ) call iprintLF ;Write 2 +32 : ( 33 ) add esp, 8 ;désallocation des variables locales +33 : ( 34 ) pop ebp ;restaure la valeur de ebp +34 : ( ) ret ; diff --git a/test/fg-ref/tab4.fg b/test/fg-ref/tab4.fg new file mode 100644 index 0000000000000000000000000000000000000000..20eaf9bcb9a8cf74653312e3db0adbb8a744b592 --- /dev/null +++ b/test/fg-ref/tab4.fg @@ -0,0 +1,29 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov r3, 0 ; +8 : ( 9 ) mov dword [tab+4*r3], 1 ;Affect +9 : ( 10 ) mov r5, 0 ; +10 : ( 11 ) mov r4, dword [tab+4*r5] ; +11 : ( 12 ) mov dword [tab+4*r4], 12 ;Affect +12 : ( 13 ) mov r6, 0 ; +13 : ( 14 ) mov r0, dword [tab+4*r6] ; +14 : ( 15 ) add r0, 1 ; +15 : ( 16 ) mov r7, r0 ; +16 : ( 17 ) mov dword [tab+4*r7], 13 ;Affect +17 : ( 18 ) mov r9, 0 ; +18 : ( 19 ) mov eax, dword [tab+4*r9] ;Write 1 +19 : ( ) call iprintLF ;Write 2 +20 : ( 21 ) mov r11, 1 ; +21 : ( 22 ) mov eax, dword [tab+4*r11] ;Write 1 +22 : ( ) call iprintLF ;Write 2 +23 : ( 24 ) mov r13, 2 ; +24 : ( 25 ) mov eax, dword [tab+4*r13] ;Write 1 +25 : ( ) call iprintLF ;Write 2 +26 : ( 27 ) add esp, 0 ;désallocation des variables locales +27 : ( 28 ) pop ebp ;restaure la valeur de ebp +28 : ( ) ret ; diff --git a/test/fg-ref/tantque1.fg b/test/fg-ref/tantque1.fg new file mode 100644 index 0000000000000000000000000000000000000000..55ad05905333245130db75f184611cf7f3868a5a --- /dev/null +++ b/test/fg-ref/tantque1.fg @@ -0,0 +1,26 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 4 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 10 ;Affect +8 : ( 9 ) l0 : mov r0, 1 ;Affect +9 : ( 10 ) mov r4, 0 ;JumpIfLess 1 +10 : ( 11 ) cmp r4, dword [ebp-4*1] ;on passe par un registre temporaire +11 : ( 12 13 ) jl l2 ;JumpIfLess 2 +12 : ( 13 ) mov r0, 0 ;Affect +13 : ( 14 ) l2 : cmp r0, 0 ;JumpIfEqual 1 +14 : ( 15 21 ) je l1 ;JumpIfEqual 2 +15 : ( 16 ) mov eax, dword [ebp-4*1] ;Write 1 +16 : ( ) call iprintLF ;Write 2 +17 : ( 18 ) mov r1, dword [ebp-4*1] ; +18 : ( 19 ) sub r1, 1 ; +19 : ( 20 ) mov dword [ebp-4*1], r1 ;Affect +20 : ( 8 ) jmp l0 ;Jump +21 : ( 22 ) l1 : mov eax, 0 ;Write 1 +22 : ( ) call iprintLF ;Write 2 +23 : ( 24 ) add esp, 4 ;désallocation des variables locales +24 : ( 25 ) pop ebp ;restaure la valeur de ebp +25 : ( ) ret ; diff --git a/test/fg-ref/tantque2.fg b/test/fg-ref/tantque2.fg new file mode 100644 index 0000000000000000000000000000000000000000..2c74761389a78ca6265596846219675c0c8f9841 --- /dev/null +++ b/test/fg-ref/tantque2.fg @@ -0,0 +1,36 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 8 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 0 ;Affect +8 : ( 9 ) l0 : mov r0, 1 ;Affect +9 : ( 10 ) cmp dword [ebp-4*1], 4 ;JumpIfLess 1 +10 : ( 11 12 ) jl l2 ;JumpIfLess 2 +11 : ( 12 ) mov r0, 0 ;Affect +12 : ( 13 ) l2 : cmp r0, 0 ;JumpIfEqual 1 +13 : ( 14 33 ) je l1 ;JumpIfEqual 2 +14 : ( 15 ) mov dword [ebp-4*2], 0 ;Affect +15 : ( 16 ) l3 : mov r1, 1 ;Affect +16 : ( 17 ) cmp dword [ebp-4*2], 4 ;JumpIfLess 1 +17 : ( 18 19 ) jl l5 ;JumpIfLess 2 +18 : ( 19 ) mov r1, 0 ;Affect +19 : ( 20 ) l5 : cmp r1, 0 ;JumpIfEqual 1 +20 : ( 21 29 ) je l4 ;JumpIfEqual 2 +21 : ( 22 ) mov eax, dword [ebp-4*1] ;Write 1 +22 : ( ) call iprintLF ;Write 2 +23 : ( 24 ) mov eax, dword [ebp-4*2] ;Write 1 +24 : ( ) call iprintLF ;Write 2 +25 : ( 26 ) mov r2, dword [ebp-4*2] ; +26 : ( 27 ) add r2, 1 ; +27 : ( 28 ) mov dword [ebp-4*2], r2 ;Affect +28 : ( 15 ) jmp l3 ;Jump +29 : ( 30 ) l4 : mov r3, dword [ebp-4*1] ; +30 : ( 31 ) add r3, 1 ; +31 : ( 32 ) mov dword [ebp-4*1], r3 ;Affect +32 : ( 8 ) jmp l0 ;Jump +33 : ( 34 ) l1 : add esp, 8 ;désallocation des variables locales +34 : ( 35 ) pop ebp ;restaure la valeur de ebp +35 : ( ) ret ; diff --git a/test/fg-ref/varglob1.fg b/test/fg-ref/varglob1.fg new file mode 100644 index 0000000000000000000000000000000000000000..d577f3cd5d890cf4dce69d172b40a9a684385bb3 --- /dev/null +++ b/test/fg-ref/varglob1.fg @@ -0,0 +1,13 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov dword [variable], 6834 ;Affect +8 : ( 9 ) mov eax, dword [variable] ;Write 1 +9 : ( ) call iprintLF ;Write 2 +10 : ( 11 ) add esp, 0 ;désallocation des variables locales +11 : ( 12 ) pop ebp ;restaure la valeur de ebp +12 : ( ) ret ; diff --git a/test/fg-ref/varglob2.fg b/test/fg-ref/varglob2.fg new file mode 100644 index 0000000000000000000000000000000000000000..5dff65ae529b31798cfc70ab9c2817f4972a4021 --- /dev/null +++ b/test/fg-ref/varglob2.fg @@ -0,0 +1,15 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov dword [variable], 10 ;Affect +8 : ( 9 ) mov r0, dword [variable] ; +9 : ( 10 ) add r0, 50 ; +10 : ( 11 ) mov eax, r0 ;Write 1 +11 : ( ) call iprintLF ;Write 2 +12 : ( 13 ) add esp, 0 ;désallocation des variables locales +13 : ( 14 ) pop ebp ;restaure la valeur de ebp +14 : ( ) ret ; diff --git a/test/fg-ref/varglob3.fg b/test/fg-ref/varglob3.fg new file mode 100644 index 0000000000000000000000000000000000000000..869643f577fc57720f16820fd8f03d49a11d537f --- /dev/null +++ b/test/fg-ref/varglob3.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov dword [var1], 10 ;Affect +8 : ( 9 ) mov dword [var2], 34 ;Affect +9 : ( 10 ) mov eax, dword [var1] ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) mov eax, dword [var2] ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/varglob4.fg b/test/fg-ref/varglob4.fg new file mode 100644 index 0000000000000000000000000000000000000000..e020f5667fd2f0c402d16059ea5f8a05f2a49780 --- /dev/null +++ b/test/fg-ref/varglob4.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 0 ;allocation des variables locales +7 : ( 8 ) mov dword [var1], 10 ;Affect +8 : ( 9 ) mov dword [var2], 34 ;Affect +9 : ( 10 ) mov r0, dword [var1] ; +10 : ( 11 ) add r0, dword [var2] ; +11 : ( 12 ) mov eax, r0 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 0 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/varloc1.fg b/test/fg-ref/varloc1.fg new file mode 100644 index 0000000000000000000000000000000000000000..292336df32d5234203c6ec9942a4c93939e7d099 --- /dev/null +++ b/test/fg-ref/varloc1.fg @@ -0,0 +1,13 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 4 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 6834 ;Affect +8 : ( 9 ) mov eax, dword [ebp-4*1] ;Write 1 +9 : ( ) call iprintLF ;Write 2 +10 : ( 11 ) add esp, 4 ;désallocation des variables locales +11 : ( 12 ) pop ebp ;restaure la valeur de ebp +12 : ( ) ret ; diff --git a/test/fg-ref/varloc2.fg b/test/fg-ref/varloc2.fg new file mode 100644 index 0000000000000000000000000000000000000000..6e14583eb8b5ffbbde31edcc388fc00486a933ea --- /dev/null +++ b/test/fg-ref/varloc2.fg @@ -0,0 +1,15 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 4 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 10 ;Affect +8 : ( 9 ) mov r0, dword [ebp-4*1] ; +9 : ( 10 ) add r0, 50 ; +10 : ( 11 ) mov eax, r0 ;Write 1 +11 : ( ) call iprintLF ;Write 2 +12 : ( 13 ) add esp, 4 ;désallocation des variables locales +13 : ( 14 ) pop ebp ;restaure la valeur de ebp +14 : ( ) ret ; diff --git a/test/fg-ref/varloc3.fg b/test/fg-ref/varloc3.fg new file mode 100644 index 0000000000000000000000000000000000000000..6d47bc1df632ab4c5cc25f13b7d8b20ec41e3ba4 --- /dev/null +++ b/test/fg-ref/varloc3.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 8 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 10 ;Affect +8 : ( 9 ) mov dword [ebp-4*2], 30 ;Affect +9 : ( 10 ) mov eax, dword [ebp-4*1] ;Write 1 +10 : ( ) call iprintLF ;Write 2 +11 : ( 12 ) mov eax, dword [ebp-4*2] ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 8 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/varloc4.fg b/test/fg-ref/varloc4.fg new file mode 100644 index 0000000000000000000000000000000000000000..d35e2915ba017b7214026c3be3215d2ee2b9d298 --- /dev/null +++ b/test/fg-ref/varloc4.fg @@ -0,0 +1,16 @@ +0 : ( 4 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) main : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 8 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 10 ;Affect +8 : ( 9 ) mov dword [ebp-4*2], 30 ;Affect +9 : ( 10 ) mov r0, dword [ebp-4*1] ; +10 : ( 11 ) add r0, dword [ebp-4*2] ; +11 : ( 12 ) mov eax, r0 ;Write 1 +12 : ( ) call iprintLF ;Write 2 +13 : ( 14 ) add esp, 8 ;désallocation des variables locales +14 : ( 15 ) pop ebp ;restaure la valeur de ebp +15 : ( ) ret ; diff --git a/test/fg-ref/varloc5.fg b/test/fg-ref/varloc5.fg new file mode 100644 index 0000000000000000000000000000000000000000..a4a15a3b506e80fc8f03eaa92515cc9d67554743 --- /dev/null +++ b/test/fg-ref/varloc5.fg @@ -0,0 +1,25 @@ +0 : ( 13 ) call main ; +1 : ( 2 ) mov ebx, 0 ; valeur de retour du programme +2 : ( 3 ) mov eax, 1 ; +3 : ( 4 ) int 0x80 ; +4 : ( 5 ) f : push ebp ;sauvegarde la valeur de ebp +5 : ( 6 ) mov ebp, esp ;nouvelle valeur de ebp +6 : ( 7 ) sub esp, 4 ;allocation des variables locales +7 : ( 8 ) mov dword [ebp-4*1], 10 ;Affect +8 : ( 9 ) mov eax, dword [ebp-4*1] ;Write 1 +9 : ( ) call iprintLF ;Write 2 +10 : ( 11 ) add esp, 4 ;désallocation des variables locales +11 : ( 12 ) pop ebp ;restaure la valeur de ebp +12 : ( 13 ) ret ; +13 : ( 14 ) main : push ebp ;sauvegarde la valeur de ebp +14 : ( 15 ) mov ebp, esp ;nouvelle valeur de ebp +15 : ( 16 ) sub esp, 0 ;allocation des variables locales +16 : ( 17 ) mov dword [var1], 20 ;Affect +17 : ( 18 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +18 : ( 4 ) call f ; +19 : ( 20 ) pop r0 ;récupération de la valeur de retour +20 : ( 21 ) mov eax, dword [var1] ;Write 1 +21 : ( ) call iprintLF ;Write 2 +22 : ( 23 ) add esp, 0 ;désallocation des variables locales +23 : ( 24 ) pop ebp ;restaure la valeur de ebp +24 : ( ) ret ; diff --git a/test/fgs-ref/add1.fgs b/test/fgs-ref/add1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..17c0fa4b6fc4f774c5886e47cdb25f69a8e81070 --- /dev/null +++ b/test/fgs-ref/add1.fgs @@ -0,0 +1,15 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 3 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, 10 ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/add2.fgs b/test/fgs-ref/add2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..d8a2e66f8fe6c42994bd79483c264723e8610ace --- /dev/null +++ b/test/fgs-ref/add2.fgs @@ -0,0 +1,17 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 2 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, 4 ; +use = (0 ) def = (1 ) in = (0 ) out = (1 ) mov r1, r0 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) add r1, 8 ; +use = (1 ) def = (4 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/affect1.fgs b/test/fgs-ref/affect1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..859a4d2d1fefb2e9387c66915834cdc351e59c05 --- /dev/null +++ b/test/fgs-ref/affect1.fgs @@ -0,0 +1,14 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () mov dword [a], 1 ;Affect +use = () def = (2 ) in = () out = () mov eax, dword [a] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/affect2.fgs b/test/fgs-ref/affect2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..b254e126217ee1595c5ef3925be11e55ba697c20 --- /dev/null +++ b/test/fgs-ref/affect2.fgs @@ -0,0 +1,14 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 1 ;Affect +use = () def = (2 ) in = () out = () mov eax, dword [ebp-4*1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/affect3.fgs b/test/fgs-ref/affect3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..82b824f24c75edfaca1b0ed9f293981b32ec1cc1 --- /dev/null +++ b/test/fgs-ref/affect3.fgs @@ -0,0 +1,25 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp+4*3], 1 ;Affect +use = () def = (3 ) in = () out = () mov eax, dword [ebp+4*3] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () push 3 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 4 ;désallocation des arguments +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/and1.fgs b/test/fgs-ref/and1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..693935068b3d1125e2406f25f691d6eb607841d0 --- /dev/null +++ b/test/fgs-ref/and1.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 3 ;JumpIfEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 1 ;JumpIfEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/and2.fgs b/test/fgs-ref/and2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..d0cb5b744acc86dccfd051ea48fb50e6b6112544 --- /dev/null +++ b/test/fgs-ref/and2.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 4 ;JumpIfEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 0 ;JumpIfEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/and3.fgs b/test/fgs-ref/and3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..6ce510711c9795242fa0b16bc0e37e1b89e3ad89 --- /dev/null +++ b/test/fgs-ref/and3.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 0 ;JumpIfEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 1024 ;JumpIfEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/and4.fgs b/test/fgs-ref/and4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..a83cb5aa55c3a979e8921fb13f699fd6c628e1e3 --- /dev/null +++ b/test/fgs-ref/and4.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 0 ;JumpIfEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 0 ;JumpIfEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/and5.fgs b/test/fgs-ref/and5.fgs new file mode 100644 index 0000000000000000000000000000000000000000..b0d28d20e458686fe8ea5fedf4602fef9852c328 --- /dev/null +++ b/test/fgs-ref/and5.fgs @@ -0,0 +1,30 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = () out = (4 ) mov r4, 1 ;JumpIfEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (5 ) in = () out = (5 ) mov r5, 0 ;JumpIfEqual 1 +use = (5 ) def = () in = (5 ) out = () cmp r5, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = () in = (1 ) out = (1 ) jmp l2 ;Jump +use = () def = (1 ) in = () out = (1 ) l3 : mov r1, 0 ;Affect +use = (1 ) def = () in = (1 ) out = () l2 : cmp r1, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (6 ) in = () out = (6 ) mov r6, 1 ;JumpIfEqual 1 +use = (6 ) def = () in = (6 ) out = () cmp r6, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 0 ;Affect +use = (0 ) def = (7 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/appel-param1.fgs b/test/fgs-ref/appel-param1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..2e08d5744b3cd30db48af501e7d4f78fc2573ba5 --- /dev/null +++ b/test/fgs-ref/appel-param1.fgs @@ -0,0 +1,24 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = () mov eax, dword [ebp+4*3] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () push 1 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 4 ;désallocation des arguments +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/appel-param2.fgs b/test/fgs-ref/appel-param2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..2ffaa3927dd30e5244f5b777ec8d2cc1a685ec97 --- /dev/null +++ b/test/fgs-ref/appel-param2.fgs @@ -0,0 +1,27 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = () mov eax, dword [ebp+4*4] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (4 ) in = () out = () mov eax, dword [ebp+4*3] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () push 1 ;Param +use = () def = () in = () out = () push 456 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 8 ;désallocation des arguments +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/appel-param3.fgs b/test/fgs-ref/appel-param3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..3bbb753332548d06983fc9b6ec3f866b880f2c37 --- /dev/null +++ b/test/fgs-ref/appel-param3.fgs @@ -0,0 +1,36 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = () mov eax, dword [ebp+4*7] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (4 ) in = () out = () mov eax, dword [ebp+4*6] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (5 ) in = () out = () mov eax, dword [ebp+4*5] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (6 ) in = () out = () mov eax, dword [ebp+4*4] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (7 ) in = () out = () mov eax, dword [ebp+4*3] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () push 1 ;Param +use = () def = () in = () out = () push 2 ;Param +use = () def = () in = () out = () push 3 ;Param +use = () def = () in = () out = () push 4 ;Param +use = () def = () in = () out = () push 5 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 20 ;désallocation des arguments +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/appel-retour1.fgs b/test/fgs-ref/appel-retour1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..1b39c7976f1335b8948fd541463449c64eddd2c8 --- /dev/null +++ b/test/fgs-ref/appel-retour1.fgs @@ -0,0 +1,26 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, dword [ebp+4*3] ;ecriture de la valeur de retour +use = (3 ) def = () in = (3 ) out = () mov dword [ebp+4*2], r3 ;on passe par un registre temporaire +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () push 3712 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = (0 ) pop r0 ;récupération de la valeur de retour +use = () def = () in = (0 ) out = (0 ) add esp, 4 ;désallocation des arguments +use = (0 ) def = (4 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/appel1.fgs b/test/fgs-ref/appel1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..9849940b8f0f8c051137d4d5877a03b21c1e459a --- /dev/null +++ b/test/fgs-ref/appel1.fgs @@ -0,0 +1,22 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/appel2.fgs b/test/fgs-ref/appel2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..383566696df8008c58f9368119a8da3dc9e0fb4c --- /dev/null +++ b/test/fgs-ref/appel2.fgs @@ -0,0 +1,33 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () g : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = () out = () mov eax, 2 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (5 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call g ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (1 ) in = () out = () pop r1 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/appel3.fgs b/test/fgs-ref/appel3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..08f881217330ef26dcc05207fc696c0dd13bf8b8 --- /dev/null +++ b/test/fgs-ref/appel3.fgs @@ -0,0 +1,33 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () g : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = () out = () mov eax, 2 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (5 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call g ; +use = () def = (1 ) in = () out = () pop r1 ;récupération de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/div1.fgs b/test/fgs-ref/div1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..d1f10647a104f9d9ffcd5c9a434112233104fa0e --- /dev/null +++ b/test/fgs-ref/div1.fgs @@ -0,0 +1,17 @@ +iter num = 20 +use = () def = () in = (5 ) out = (5 ) call main ; +use = () def = (1 ) in = (5 ) out = (5 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = (5 ) out = (5 ) mov eax, 1 ; +use = () def = () in = (5 ) out = (5 ) int 0x80 ; +use = () def = () in = (5 ) out = (5 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (5 ) out = (5 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (5 ) out = (5 ) sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = (5 ) out = (5 ) mov eax, 4 ; +use = () def = (4 ) in = (5 ) out = (4 5 ) mov r4, 2 ; +use = (4 ) def = () in = (4 5 ) out = (5 ) idiv r4 ; +use = (5 ) def = (0 ) in = (5 ) out = (0 ) mov r0, eax ; +use = (0 ) def = (6 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/div2.fgs b/test/fgs-ref/div2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..eeaaedbe3b323904b0ee4e6454c161a78d240dc6 --- /dev/null +++ b/test/fgs-ref/div2.fgs @@ -0,0 +1,17 @@ +iter num = 20 +use = () def = () in = (5 ) out = (5 ) call main ; +use = () def = (1 ) in = (5 ) out = (5 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = (5 ) out = (5 ) mov eax, 1 ; +use = () def = () in = (5 ) out = (5 ) int 0x80 ; +use = () def = () in = (5 ) out = (5 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (5 ) out = (5 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (5 ) out = (5 ) sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = (5 ) out = (5 ) mov eax, 0 ; +use = () def = (4 ) in = (5 ) out = (4 5 ) mov r4, 712 ; +use = (4 ) def = () in = (4 5 ) out = (5 ) idiv r4 ; +use = (5 ) def = (0 ) in = (5 ) out = (0 ) mov r0, eax ; +use = (0 ) def = (6 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/div3.fgs b/test/fgs-ref/div3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..1fb235a671243c1afcfd9946819cd8d9f9ad473c --- /dev/null +++ b/test/fgs-ref/div3.fgs @@ -0,0 +1,21 @@ +iter num = 28 +use = () def = () in = (6 9 ) out = (6 9 ) call main ; +use = () def = (2 ) in = (6 9 ) out = (6 9 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = (6 9 ) out = (6 9 ) mov eax, 1 ; +use = () def = () in = (6 9 ) out = (6 9 ) int 0x80 ; +use = () def = () in = (6 9 ) out = (6 9 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (6 9 ) out = (6 9 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (6 9 ) out = (6 9 ) sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = (6 9 ) out = (6 9 ) mov eax, 4 ; +use = () def = (5 ) in = (6 9 ) out = (5 6 9 ) mov r5, 2 ; +use = (5 ) def = () in = (5 6 9 ) out = (6 9 ) idiv r5 ; +use = (6 ) def = (0 ) in = (6 9 ) out = (0 9 ) mov r0, eax ; +use = (0 ) def = (7 ) in = (0 9 ) out = (9 ) mov eax, r0 ; +use = () def = (8 ) in = (9 ) out = (8 9 ) mov r8, 2 ; +use = (8 ) def = () in = (8 9 ) out = (9 ) idiv r8 ; +use = (9 ) def = (1 ) in = (9 ) out = (1 ) mov r1, eax ; +use = (1 ) def = (10 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/div4.fgs b/test/fgs-ref/div4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..388ed25f0d3482ae32b7ae1f4d980119ef025436 --- /dev/null +++ b/test/fgs-ref/div4.fgs @@ -0,0 +1,17 @@ +iter num = 20 +use = () def = () in = (5 ) out = (5 ) call main ; +use = () def = (1 ) in = (5 ) out = (5 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = (5 ) out = (5 ) mov eax, 1 ; +use = () def = () in = (5 ) out = (5 ) int 0x80 ; +use = () def = () in = (5 ) out = (5 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (5 ) out = (5 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (5 ) out = (5 ) sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = (5 ) out = (5 ) mov eax, 2 ; +use = () def = (4 ) in = (5 ) out = (4 5 ) mov r4, 3 ; +use = (4 ) def = () in = (4 5 ) out = (5 ) idiv r4 ; +use = (5 ) def = (0 ) in = (5 ) out = (0 ) mov r0, eax ; +use = (0 ) def = (6 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/ecrire1.fgs b/test/fgs-ref/ecrire1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..b592fbbb79ff9c70bc8aa7e0095f2f4dfd3a00f5 --- /dev/null +++ b/test/fgs-ref/ecrire1.fgs @@ -0,0 +1,13 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = () mov eax, 3456 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/ecrire2.fgs b/test/fgs-ref/ecrire2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..49681220f220d3f187d0f1bc1dd4918df78bb65e --- /dev/null +++ b/test/fgs-ref/ecrire2.fgs @@ -0,0 +1,13 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = () mov eax, 0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/egal1.fgs b/test/fgs-ref/egal1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..0548751c846d9c7c66bd994e0b20ed48667c7005 --- /dev/null +++ b/test/fgs-ref/egal1.fgs @@ -0,0 +1,18 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (3 ) in = (0 ) out = (0 3 ) mov r3, 123 ;JumpIfEqual 1 +use = (3 ) def = () in = (0 3 ) out = (0 ) cmp r3, 123 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/egal2.fgs b/test/fgs-ref/egal2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..41b4e6b478489ea7b74ef10931f05e2e6bac1c65 --- /dev/null +++ b/test/fgs-ref/egal2.fgs @@ -0,0 +1,18 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (3 ) in = (0 ) out = (0 3 ) mov r3, 412 ;JumpIfEqual 1 +use = (3 ) def = () in = (0 3 ) out = (0 ) cmp r3, 34 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/egal3.fgs b/test/fgs-ref/egal3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..8122de067b2b5e3e66d301620b32abfc3e0c9eb4 --- /dev/null +++ b/test/fgs-ref/egal3.fgs @@ -0,0 +1,22 @@ +iter num = 11 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = (4 ) in = (1 ) out = (1 4 ) mov r4, 2 ;JumpIfEqual 1 +use = (4 ) def = () in = (1 4 ) out = (1 ) cmp r4, 2 ;on passe par un registre temporaire +use = () def = () in = (1 ) out = (1 ) je l1 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = () def = (0 ) in = (1 ) out = (0 1 ) l1 : mov r0, 1 ;Affect +use = (1 ) def = () in = (0 1 ) out = (0 ) cmp r1, 1 ;JumpIfEqual 1 +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/err5.fgs b/test/fgs-ref/err5.fgs new file mode 100644 index 0000000000000000000000000000000000000000..a381c2737778c68846cf7e639cd94c59ec18c64d --- /dev/null +++ b/test/fgs-ref/err5.fgs @@ -0,0 +1,23 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = (0 ) pop r0 ;récupération de la valeur de retour +use = (0 ) def = () in = (0 ) out = () mov dword [ebp-4*1], r0 ;Affect +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/fibo.fgs b/test/fgs-ref/fibo.fgs new file mode 100644 index 0000000000000000000000000000000000000000..5806ac51765c68d3f404664884d8e2c6d742f0c7 --- /dev/null +++ b/test/fgs-ref/fibo.fgs @@ -0,0 +1,81 @@ +iter num = 19 +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = (8 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (9 ) in = () out = () mov eax, 1 ; code de sortie +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () fibo : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () push eax ;sauvegarde de eax +use = () def = () in = () out = () push ebx ;sauvegarde de ebx +use = () def = () in = () out = () push ecx ;sauvegarde de ecx +use = () def = () in = () out = () push edx ;sauvegarde de edx +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = () in = (1 ) out = (1 ) cmp dword [ebp+12], 2 ;JumpIfLess 1 +use = () def = () in = (1 ) out = (1 ) jl l2 ;JumpIfLess 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = (1 ) def = () in = (1 ) out = () l2 : cmp r1, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l0 ;JumpIfEqual 2 +use = () def = () in = () out = () mov dword [ebp+8], 1 ;ecriture de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = (14 ) in = () out = () pop edx ;restaure edx +use = () def = (15 ) in = () out = () pop ecx ;restaure ecx +use = () def = (16 ) in = () out = () pop ebx ;restaure ebx +use = () def = (17 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () jmp l1 ;Jump +use = () def = (3 ) in = () out = (3 ) l0 : mov r3, dword [ebp+12] ; +use = (3 ) def = (3 ) in = (3 ) out = () sub r3, 1 ; +use = () def = () in = () out = () push r3 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call fibo ; +use = () def = (2 ) in = () out = (2 ) pop r2 ;récupération de la valeur de retour +use = () def = () in = (2 ) out = (2 ) add esp, 4 ;désallocation des arguments +use = () def = (5 ) in = (2 ) out = (2 5 ) mov r5, dword [ebp+12] ; +use = (5 ) def = (5 ) in = (2 5 ) out = (2 ) sub r5, 2 ; +use = () def = () in = (2 ) out = (2 ) push r5 ;Param +use = () def = () in = (2 ) out = (2 ) sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = (2 ) out = (2 ) call fibo ; +use = () def = (4 ) in = (2 ) out = (2 4 ) pop r4 ;récupération de la valeur de retour +use = () def = () in = (2 4 ) out = (2 4 ) add esp, 4 ;désallocation des arguments +use = (2 ) def = (6 ) in = (2 4 ) out = (4 6 ) mov r6, r2 ; +use = (4 6 ) def = (6 ) in = (4 6 ) out = (6 ) add r6, r4 ; +use = (6 ) def = () in = (6 ) out = () mov dword [ebp+8], r6 ;ecriture de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = (18 ) in = () out = () pop edx ;restaure edx +use = () def = (19 ) in = () out = () pop ecx ;restaure ecx +use = () def = (20 ) in = () out = () pop ebx ;restaure ebx +use = () def = (21 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () l1 : add esp, 0 ;désallocation des variables locales +use = () def = (22 ) in = () out = () pop edx ;restaure edx +use = () def = (23 ) in = () out = () pop ecx ;restaure ecx +use = () def = (24 ) in = () out = () pop ebx ;restaure ebx +use = () def = (25 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () push eax ;sauvegarde de eax +use = () def = () in = () out = () push ebx ;sauvegarde de ebx +use = () def = () in = () out = () push ecx ;sauvegarde de ecx +use = () def = () in = () out = () push edx ;sauvegarde de edx +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () push 9 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call fibo ; +use = () def = (7 ) in = () out = (7 ) pop r7 ;récupération de la valeur de retour +use = () def = () in = (7 ) out = (7 ) add esp, 4 ;désallocation des arguments +use = (7 ) def = (30 ) in = (7 ) out = () mov eax, r7 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = (31 ) in = () out = () pop edx ;restaure edx +use = () def = (32 ) in = () out = () pop ecx ;restaure ecx +use = () def = (33 ) in = () out = () pop ebx ;restaure ebx +use = () def = (34 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/inf1.fgs b/test/fgs-ref/inf1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..86888167350ed928c637874d6779e46aa41eb822 --- /dev/null +++ b/test/fgs-ref/inf1.fgs @@ -0,0 +1,18 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (3 ) in = (0 ) out = (0 3 ) mov r3, 3 ;JumpIfLess 1 +use = (3 ) def = () in = (0 3 ) out = (0 ) cmp r3, 3 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) jl l0 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/inf2.fgs b/test/fgs-ref/inf2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..8be613be4f6de19743a5ace45dbbd420136d02d0 --- /dev/null +++ b/test/fgs-ref/inf2.fgs @@ -0,0 +1,18 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (3 ) in = (0 ) out = (0 3 ) mov r3, 4 ;JumpIfLess 1 +use = (3 ) def = () in = (0 3 ) out = (0 ) cmp r3, 1 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) jl l0 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/inf3.fgs b/test/fgs-ref/inf3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..7484453388a8529a97ab53a106871b8566633092 --- /dev/null +++ b/test/fgs-ref/inf3.fgs @@ -0,0 +1,18 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (3 ) in = (0 ) out = (0 3 ) mov r3, 312 ;JumpIfLess 1 +use = (3 ) def = () in = (0 3 ) out = (0 ) cmp r3, 475 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) jl l0 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/inf4.fgs b/test/fgs-ref/inf4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..7f8fd1c286bb814abbe5df8dc9a3374f00e410ab --- /dev/null +++ b/test/fgs-ref/inf4.fgs @@ -0,0 +1,22 @@ +iter num = 11 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = (4 ) in = (1 ) out = (1 4 ) mov r4, 3 ;JumpIfLess 1 +use = (4 ) def = () in = (1 4 ) out = (1 ) cmp r4, 2 ;on passe par un registre temporaire +use = () def = () in = (1 ) out = (1 ) jl l1 ;JumpIfLess 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = () def = (0 ) in = (1 ) out = (0 1 ) l1 : mov r0, 1 ;Affect +use = (1 ) def = () in = (0 1 ) out = (0 ) cmp r1, 1 ;JumpIfLess 1 +use = () def = () in = (0 ) out = (0 ) jl l0 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/mult1.fgs b/test/fgs-ref/mult1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..744a496103431b17fbb3cdc8f520906198e54b16 --- /dev/null +++ b/test/fgs-ref/mult1.fgs @@ -0,0 +1,15 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 2 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) imul r0, 3 ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/mult2.fgs b/test/fgs-ref/mult2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..283b9c8f008d6a223344bdbff4793a7ecfd25712 --- /dev/null +++ b/test/fgs-ref/mult2.fgs @@ -0,0 +1,15 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) imul r0, 321 ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/mult3.fgs b/test/fgs-ref/mult3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..7a190b659155de7b8bf087eded03df410b9b619d --- /dev/null +++ b/test/fgs-ref/mult3.fgs @@ -0,0 +1,17 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 3 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) imul r0, 3 ; +use = (0 ) def = (1 ) in = (0 ) out = (1 ) mov r1, r0 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) imul r1, 2 ; +use = (1 ) def = (4 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/not1.fgs b/test/fgs-ref/not1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..eab7c02a95e3840477fc7173ac6a463efdf087cb --- /dev/null +++ b/test/fgs-ref/not1.fgs @@ -0,0 +1,18 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (3 ) in = (0 ) out = (0 3 ) mov r3, 312 ;JumpIfEqual 1 +use = (3 ) def = () in = (0 3 ) out = (0 ) cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/not2.fgs b/test/fgs-ref/not2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..73c8d3fd36ded41dd11f437fcd0f05acbd6b78f0 --- /dev/null +++ b/test/fgs-ref/not2.fgs @@ -0,0 +1,18 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (3 ) in = (0 ) out = (0 3 ) mov r3, 0 ;JumpIfEqual 1 +use = (3 ) def = () in = (0 3 ) out = (0 ) cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/not3.fgs b/test/fgs-ref/not3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..2a71dd0b634046efcd23b14404713a886c8954ce --- /dev/null +++ b/test/fgs-ref/not3.fgs @@ -0,0 +1,22 @@ +iter num = 11 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = (4 ) in = (1 ) out = (1 4 ) mov r4, 0 ;JumpIfEqual 1 +use = (4 ) def = () in = (1 4 ) out = (1 ) cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = (1 ) out = (1 ) je l1 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = () def = (0 ) in = (1 ) out = (0 1 ) l1 : mov r0, 1 ;Affect +use = (1 ) def = () in = (0 1 ) out = (0 ) cmp r1, 0 ;JumpIfEqual 1 +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/or1.fgs b/test/fgs-ref/or1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..aa71c4cb9b753ea840f899f9a59503132865f1a6 --- /dev/null +++ b/test/fgs-ref/or1.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 1 ;jumpIfNotEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 1 ;jumpIfNotEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 1 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/or2.fgs b/test/fgs-ref/or2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..7094e618fd7bd0acbad38b3e22c11850acf82510 --- /dev/null +++ b/test/fgs-ref/or2.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 1 ;jumpIfNotEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 0 ;jumpIfNotEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 1 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/or3.fgs b/test/fgs-ref/or3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..5b331bd9e8ef1c33c6bace399871cff1895df758 --- /dev/null +++ b/test/fgs-ref/or3.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 0 ;jumpIfNotEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 315 ;jumpIfNotEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 1 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/or4.fgs b/test/fgs-ref/or4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..86503bbfcdf08d3ed890544cb6eb5f55a4256764 --- /dev/null +++ b/test/fgs-ref/or4.fgs @@ -0,0 +1,22 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 0 ;jumpIfNotEqual 1 +use = (3 ) def = () in = (3 ) out = () cmp r3, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (4 ) in = () out = (4 ) mov r4, 0 ;jumpIfNotEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 1 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/or5.fgs b/test/fgs-ref/or5.fgs new file mode 100644 index 0000000000000000000000000000000000000000..a14bf64d0d995cecf458b2a9a3972678d026da38 --- /dev/null +++ b/test/fgs-ref/or5.fgs @@ -0,0 +1,30 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = () out = (4 ) mov r4, 0 ;jumpIfNotEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l3 ;jumpIfNotEqual 2 +use = () def = (5 ) in = () out = (5 ) mov r5, 1 ;jumpIfNotEqual 1 +use = (5 ) def = () in = (5 ) out = () cmp r5, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l3 ;jumpIfNotEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = () def = () in = (1 ) out = (1 ) jmp l2 ;Jump +use = () def = (1 ) in = () out = (1 ) l3 : mov r1, 1 ;Affect +use = (1 ) def = () in = (1 ) out = () l2 : cmp r1, 0 ;jumpIfNotEqual 1 +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (6 ) in = () out = (6 ) mov r6, 0 ;jumpIfNotEqual 1 +use = (6 ) def = () in = (6 ) out = () cmp r6, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 1 ;Affect +use = (0 ) def = (7 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/parenth1.fgs b/test/fgs-ref/parenth1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..2aed1a1e27a1f1ef99bb3d6f6771f7edb357e6bd --- /dev/null +++ b/test/fgs-ref/parenth1.fgs @@ -0,0 +1,13 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/parenth2.fgs b/test/fgs-ref/parenth2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..8f2d29989ce9513dd4844fe46f6a89c01f29618b --- /dev/null +++ b/test/fgs-ref/parenth2.fgs @@ -0,0 +1,13 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = () mov eax, 2 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio23-1.fgs b/test/fgs-ref/prio23-1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..d50f451ef61bf1ecd3755d7c1d6d6dcc580aa3fc --- /dev/null +++ b/test/fgs-ref/prio23-1.fgs @@ -0,0 +1,20 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (4 ) in = (0 ) out = (0 4 ) mov r4, 0 ;JumpIfEqual 1 +use = (4 ) def = () in = (0 4 ) out = (0 ) cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (1 ) in = (0 ) out = (1 ) l0 : mov r1, r0 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) imul r1, 10 ; +use = (1 ) def = (5 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio23-2.fgs b/test/fgs-ref/prio23-2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..ca8580fd0e16adac0f14cdc510236f716b841310 --- /dev/null +++ b/test/fgs-ref/prio23-2.fgs @@ -0,0 +1,20 @@ +iter num = 11 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = (4 ) in = (0 ) out = (0 4 ) mov r4, 10 ;JumpIfEqual 1 +use = (4 ) def = () in = (0 4 ) out = (0 ) cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = (1 ) in = (0 ) out = (0 1 ) l0 : mov r1, 3 ; +use = (0 1 ) def = (1 ) in = (0 1 ) out = (1 ) imul r1, r0 ; +use = (1 ) def = (5 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio23-3.fgs b/test/fgs-ref/prio23-3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..6bb0cc3c91d82ef78e7d8d6c9b1e7eb5a0a651ac --- /dev/null +++ b/test/fgs-ref/prio23-3.fgs @@ -0,0 +1,22 @@ +iter num = 28 +use = () def = () in = (7 ) out = (7 ) call main ; +use = () def = (2 ) in = (7 ) out = (7 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = (7 ) out = (7 ) mov eax, 1 ; +use = () def = () in = (7 ) out = (7 ) int 0x80 ; +use = () def = () in = (7 ) out = (7 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (7 ) out = (7 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (7 ) out = (7 ) sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = (7 ) out = (0 7 ) mov r0, 1 ;Affect +use = () def = (4 ) in = (0 7 ) out = (0 4 7 ) mov r4, 0 ;JumpIfEqual 1 +use = (4 ) def = () in = (0 4 7 ) out = (0 7 ) cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = (0 7 ) out = (0 7 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = (7 ) out = (0 7 ) mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 7 ) out = (7 ) l0 : mov eax, r0 ; +use = () def = (6 ) in = (7 ) out = (6 7 ) mov r6, 1 ; +use = (6 ) def = () in = (6 7 ) out = (7 ) idiv r6 ; +use = (7 ) def = (1 ) in = (7 ) out = (1 ) mov r1, eax ; +use = (1 ) def = (8 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio23-4.fgs b/test/fgs-ref/prio23-4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..31cb97ed7ea6a1d718d1169cea812aa639957796 --- /dev/null +++ b/test/fgs-ref/prio23-4.fgs @@ -0,0 +1,26 @@ +iter num = 34 +use = () def = () in = (8 ) out = (8 ) call main ; +use = () def = (3 ) in = (8 ) out = (8 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (4 ) in = (8 ) out = (8 ) mov eax, 1 ; +use = () def = () in = (8 ) out = (8 ) int 0x80 ; +use = () def = () in = (8 ) out = (8 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (8 ) out = (8 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (8 ) out = (8 ) sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = (8 ) out = (0 8 ) mov r0, 1 ;Affect +use = () def = (5 ) in = (0 8 ) out = (0 5 8 ) mov r5, 1 ;JumpIfEqual 1 +use = (5 ) def = () in = (0 5 8 ) out = (0 8 ) cmp r5, 0 ;on passe par un registre temporaire +use = () def = () in = (0 8 ) out = (0 8 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = (8 ) out = (0 8 ) mov r0, 0 ;Affect +use = () def = (1 ) in = (0 8 ) out = (0 1 8 ) l0 : mov r1, 1 ;Affect +use = () def = (6 ) in = (0 1 8 ) out = (0 1 6 8 ) mov r6, 0 ;JumpIfEqual 1 +use = (6 ) def = () in = (0 1 6 8 ) out = (0 1 8 ) cmp r6, 0 ;on passe par un registre temporaire +use = () def = () in = (0 1 8 ) out = (0 1 8 ) je l1 ;JumpIfEqual 2 +use = () def = (1 ) in = (0 8 ) out = (0 1 8 ) mov r1, 0 ;Affect +use = (0 ) def = (7 ) in = (0 1 8 ) out = (1 8 ) l1 : mov eax, r0 ; +use = (1 ) def = () in = (1 8 ) out = (8 ) idiv r1 ; +use = (8 ) def = (2 ) in = (8 ) out = (2 ) mov r2, eax ; +use = (2 ) def = (9 ) in = (2 ) out = () mov eax, r2 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio34-1.fgs b/test/fgs-ref/prio34-1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..fadac07bb639a07a07789ab65389b9c3e6ab5f8f --- /dev/null +++ b/test/fgs-ref/prio34-1.fgs @@ -0,0 +1,17 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 3 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) imul r0, 4 ; +use = () def = (1 ) in = (0 ) out = (0 1 ) mov r1, 2 ; +use = (0 1 ) def = (1 ) in = (0 1 ) out = (1 ) add r1, r0 ; +use = (1 ) def = (4 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio34-2.fgs b/test/fgs-ref/prio34-2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..ffeb7df9c19e5dd8d8b10f8ef42a9f13bdd8544e --- /dev/null +++ b/test/fgs-ref/prio34-2.fgs @@ -0,0 +1,17 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 2 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) imul r0, 3 ; +use = (0 ) def = (1 ) in = (0 ) out = (1 ) mov r1, r0 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) sub r1, 4 ; +use = (1 ) def = (4 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio34-3.fgs b/test/fgs-ref/prio34-3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..aba865583aaa7417c42e5fc3c2058db173fcdbec --- /dev/null +++ b/test/fgs-ref/prio34-3.fgs @@ -0,0 +1,19 @@ +iter num = 20 +use = () def = () in = (6 ) out = (6 ) call main ; +use = () def = (2 ) in = (6 ) out = (6 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = (6 ) out = (6 ) mov eax, 1 ; +use = () def = () in = (6 ) out = (6 ) int 0x80 ; +use = () def = () in = (6 ) out = (6 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (6 ) out = (6 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (6 ) out = (6 ) sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = (6 ) out = (6 ) mov eax, 6 ; +use = () def = (5 ) in = (6 ) out = (5 6 ) mov r5, 3 ; +use = (5 ) def = () in = (5 6 ) out = (6 ) idiv r5 ; +use = (6 ) def = (0 ) in = (6 ) out = (0 ) mov r0, eax ; +use = (0 ) def = (1 ) in = (0 ) out = (1 ) mov r1, r0 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) sub r1, 72 ; +use = (1 ) def = (7 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio34-4.fgs b/test/fgs-ref/prio34-4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..088f3df8f51b430dc173df14810ddb7583287391 --- /dev/null +++ b/test/fgs-ref/prio34-4.fgs @@ -0,0 +1,19 @@ +iter num = 20 +use = () def = () in = (6 ) out = (6 ) call main ; +use = () def = (2 ) in = (6 ) out = (6 ) mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = (6 ) out = (6 ) mov eax, 1 ; +use = () def = () in = (6 ) out = (6 ) int 0x80 ; +use = () def = () in = (6 ) out = (6 ) main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = (6 ) out = (6 ) mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = (6 ) out = (6 ) sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = (6 ) out = (6 ) mov eax, 20 ; +use = () def = (5 ) in = (6 ) out = (5 6 ) mov r5, 10 ; +use = (5 ) def = () in = (5 6 ) out = (6 ) idiv r5 ; +use = (6 ) def = (0 ) in = (6 ) out = (0 ) mov r0, eax ; +use = () def = (1 ) in = (0 ) out = (0 1 ) mov r1, 6 ; +use = (0 1 ) def = (1 ) in = (0 1 ) out = (1 ) add r1, r0 ; +use = (1 ) def = (7 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio45-1.fgs b/test/fgs-ref/prio45-1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..c4e774f1529ee2682e92985800da60863534f5f1 --- /dev/null +++ b/test/fgs-ref/prio45-1.fgs @@ -0,0 +1,20 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) add r1, 1 ; +use = () def = (0 ) in = (1 ) out = (0 1 ) mov r0, 1 ;Affect +use = () def = (4 ) in = (0 1 ) out = (0 1 4 ) mov r4, 2 ;JumpIfEqual 1 +use = (1 4 ) def = () in = (0 1 4 ) out = (0 ) cmp r4, r1 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio45-2.fgs b/test/fgs-ref/prio45-2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..581d854b176806a7df8a56fdcc5319a400f87d57 --- /dev/null +++ b/test/fgs-ref/prio45-2.fgs @@ -0,0 +1,19 @@ +iter num = 7 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) add r1, 234 ; +use = () def = (0 ) in = (1 ) out = (0 1 ) mov r0, 1 ;Affect +use = (1 ) def = () in = (0 1 ) out = (0 ) cmp r1, 1 ;JumpIfEqual 1 +use = () def = () in = (0 ) out = (0 ) je l0 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio45-3.fgs b/test/fgs-ref/prio45-3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..9519f6c7f56230914cd5f92e90970663c02d1e5b --- /dev/null +++ b/test/fgs-ref/prio45-3.fgs @@ -0,0 +1,20 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 11 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) add r1, 100 ; +use = () def = (0 ) in = (1 ) out = (0 1 ) mov r0, 1 ;Affect +use = () def = (4 ) in = (0 1 ) out = (0 1 4 ) mov r4, 12 ;JumpIfLess 1 +use = (1 4 ) def = () in = (0 1 4 ) out = (0 ) cmp r4, r1 ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) jl l0 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (5 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio45-4.fgs b/test/fgs-ref/prio45-4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..2e64d12074c2b6eebcb4a0ca99f7223b0b743b1d --- /dev/null +++ b/test/fgs-ref/prio45-4.fgs @@ -0,0 +1,19 @@ +iter num = 7 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 21 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) sub r1, 21 ; +use = () def = (0 ) in = (1 ) out = (0 1 ) mov r0, 1 ;Affect +use = (1 ) def = () in = (0 1 ) out = (0 ) cmp r1, 1 ;JumpIfLess 1 +use = () def = () in = (0 ) out = (0 ) jl l0 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = (4 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio56-1.fgs b/test/fgs-ref/prio56-1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..7b84beb610d28138690c6d6a5122758c9d70c39f --- /dev/null +++ b/test/fgs-ref/prio56-1.fgs @@ -0,0 +1,26 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = (4 ) in = (1 ) out = (1 4 ) mov r4, 1 ;JumpIfEqual 1 +use = (4 ) def = () in = (1 4 ) out = (1 ) cmp r4, 2 ;on passe par un registre temporaire +use = () def = () in = (1 ) out = (1 ) je l2 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = (1 ) def = () in = (1 ) out = () l2 : cmp r1, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (5 ) in = () out = (5 ) mov r5, 1 ;JumpIfEqual 1 +use = (5 ) def = () in = (5 ) out = () cmp r5, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 0 ;Affect +use = (0 ) def = (6 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio56-2.fgs b/test/fgs-ref/prio56-2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..f4c98ddf8009f15a5494083f092c14394b9b1862 --- /dev/null +++ b/test/fgs-ref/prio56-2.fgs @@ -0,0 +1,26 @@ +iter num = 15 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = (4 ) in = (1 ) out = (1 4 ) mov r4, 2 ;JumpIfEqual 1 +use = (4 ) def = () in = (1 4 ) out = (1 ) cmp r4, 1 ;on passe par un registre temporaire +use = () def = () in = (1 ) out = (1 ) je l2 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = () def = (5 ) in = (1 ) out = (1 5 ) l2 : mov r5, 1 ;JumpIfEqual 1 +use = (5 ) def = () in = (1 5 ) out = (1 ) cmp r5, 0 ;on passe par un registre temporaire +use = () def = () in = (1 ) out = (1 ) je l1 ;JumpIfEqual 2 +use = (1 ) def = () in = (1 ) out = () cmp r1, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 0 ;Affect +use = (0 ) def = (6 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio67-1.fgs b/test/fgs-ref/prio67-1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..daa97c7ab6dcb65ba752750b257f502f2147eedf --- /dev/null +++ b/test/fgs-ref/prio67-1.fgs @@ -0,0 +1,30 @@ +iter num = 5 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = () out = (4 ) mov r4, 0 ;JumpIfEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (5 ) in = () out = (5 ) mov r5, 1 ;JumpIfEqual 1 +use = (5 ) def = () in = (5 ) out = () cmp r5, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = () in = (1 ) out = (1 ) jmp l2 ;Jump +use = () def = (1 ) in = () out = (1 ) l3 : mov r1, 0 ;Affect +use = (1 ) def = () in = (1 ) out = () l2 : cmp r1, 0 ;jumpIfNotEqual 1 +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (6 ) in = () out = (6 ) mov r6, 1 ;jumpIfNotEqual 1 +use = (6 ) def = () in = (6 ) out = () cmp r6, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 1 ;Affect +use = (0 ) def = (7 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/prio67-2.fgs b/test/fgs-ref/prio67-2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..2837740b65a52e5d35eed62373dd2c52014be0d3 --- /dev/null +++ b/test/fgs-ref/prio67-2.fgs @@ -0,0 +1,30 @@ +iter num = 11 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (4 ) in = () out = (4 ) mov r4, 1 ;JumpIfEqual 1 +use = (4 ) def = () in = (4 ) out = () cmp r4, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (5 ) in = () out = (5 ) mov r5, 0 ;JumpIfEqual 1 +use = (5 ) def = () in = (5 ) out = () cmp r5, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = () in = (1 ) out = (1 ) jmp l2 ;Jump +use = () def = (1 ) in = () out = (1 ) l3 : mov r1, 0 ;Affect +use = () def = (6 ) in = (1 ) out = (1 6 ) l2 : mov r6, 1 ;jumpIfNotEqual 1 +use = (6 ) def = () in = (1 6 ) out = (1 ) cmp r6, 0 ;on passe par un registre temporaire +use = () def = () in = (1 ) out = (1 ) jne l1 ;jumpIfNotEqual 2 +use = (1 ) def = () in = (1 ) out = () cmp r1, 0 ;jumpIfNotEqual 1 +use = () def = () in = () out = () jne l1 ;jumpIfNotEqual 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = () def = () in = (0 ) out = (0 ) jmp l0 ;Jump +use = () def = (0 ) in = () out = (0 ) l1 : mov r0, 1 ;Affect +use = (0 ) def = (7 ) in = (0 ) out = () l0 : mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/rec1.fgs b/test/fgs-ref/rec1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..3ca7549d4f97cfe481d8c2a2f881ca953b7111c9 --- /dev/null +++ b/test/fgs-ref/rec1.fgs @@ -0,0 +1,74 @@ +iter num = 7 +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = (6 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (7 ) in = () out = () mov eax, 1 ; code de sortie +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () push eax ;sauvegarde de eax +use = () def = () in = () out = () push ebx ;sauvegarde de ebx +use = () def = () in = () out = () push ecx ;sauvegarde de ecx +use = () def = () in = () out = () push edx ;sauvegarde de edx +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (1 ) in = () out = (1 ) mov r1, 1 ;Affect +use = () def = () in = (1 ) out = (1 ) cmp dword [ebp+12], 1 ;JumpIfEqual 1 +use = () def = () in = (1 ) out = (1 ) je l2 ;JumpIfEqual 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = (1 ) def = () in = (1 ) out = () l2 : cmp r1, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l0 ;JumpIfEqual 2 +use = () def = () in = () out = () mov dword [ebp+8], 1 ;ecriture de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = (12 ) in = () out = () pop edx ;restaure edx +use = () def = (13 ) in = () out = () pop ecx ;restaure ecx +use = () def = (14 ) in = () out = () pop ebx ;restaure ebx +use = () def = (15 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () jmp l1 ;Jump +use = () def = (3 ) in = () out = (3 ) l0 : mov r3, dword [ebp+12] ; +use = (3 ) def = (3 ) in = (3 ) out = () sub r3, 1 ; +use = () def = () in = () out = () push r3 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (2 ) in = () out = (2 ) pop r2 ;récupération de la valeur de retour +use = () def = () in = (2 ) out = (2 ) add esp, 4 ;désallocation des arguments +use = () def = (4 ) in = (2 ) out = (2 4 ) mov r4, 1 ; +use = (2 4 ) def = (4 ) in = (2 4 ) out = (4 ) add r4, r2 ; +use = (4 ) def = () in = (4 ) out = () mov dword [ebp+8], r4 ;ecriture de la valeur de retour +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = (16 ) in = () out = () pop edx ;restaure edx +use = () def = (17 ) in = () out = () pop ecx ;restaure ecx +use = () def = (18 ) in = () out = () pop ebx ;restaure ebx +use = () def = (19 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () l1 : add esp, 0 ;désallocation des variables locales +use = () def = (20 ) in = () out = () pop edx ;restaure edx +use = () def = (21 ) in = () out = () pop ecx ;restaure ecx +use = () def = (22 ) in = () out = () pop ebx ;restaure ebx +use = () def = (23 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () push eax ;sauvegarde de eax +use = () def = () in = () out = () push ebx ;sauvegarde de ebx +use = () def = () in = () out = () push ecx ;sauvegarde de ecx +use = () def = () in = () out = () push edx ;sauvegarde de edx +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () push 100 ;Param +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (5 ) in = () out = (5 ) pop r5 ;récupération de la valeur de retour +use = () def = () in = (5 ) out = (5 ) add esp, 4 ;désallocation des arguments +use = (5 ) def = (28 ) in = (5 ) out = () mov eax, r5 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = (29 ) in = () out = () pop edx ;restaure edx +use = () def = (30 ) in = () out = () pop ecx ;restaure ecx +use = () def = (31 ) in = () out = () pop ebx ;restaure ebx +use = () def = (32 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/si1.fgs b/test/fgs-ref/si1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..d394ed05eeb802ba056c393e9c1b86ccfe845847 --- /dev/null +++ b/test/fgs-ref/si1.fgs @@ -0,0 +1,16 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = (2 ) mov r2, 1 ;JumpIfEqual 1 +use = (2 ) def = () in = (2 ) out = () cmp r2, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (3 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () l1 : add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/si2.fgs b/test/fgs-ref/si2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..f752f202ff887676e15a9666d6a3217296a8505d --- /dev/null +++ b/test/fgs-ref/si2.fgs @@ -0,0 +1,19 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = (2 ) mov r2, 0 ;JumpIfEqual 1 +use = (2 ) def = () in = (2 ) out = () cmp r2, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l0 ;JumpIfEqual 2 +use = () def = (3 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () jmp l1 ;Jump +use = () def = (4 ) in = () out = () l0 : mov eax, 0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () l1 : add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/si3.fgs b/test/fgs-ref/si3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..d60ffe208ce5cfd94e1d4e0602ee0fb8b69a225c --- /dev/null +++ b/test/fgs-ref/si3.fgs @@ -0,0 +1,21 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = (2 ) mov r2, 1 ;JumpIfEqual 1 +use = (2 ) def = () in = (2 ) out = () cmp r2, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l0 ;JumpIfEqual 2 +use = () def = (3 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () jmp l1 ;Jump +use = () def = (4 ) in = () out = () l0 : mov eax, 0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (5 ) in = () out = () l1 : mov eax, 3 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/si4.fgs b/test/fgs-ref/si4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..8f0dfb32e517a5c1b4b81f942c6d103166b20240 --- /dev/null +++ b/test/fgs-ref/si4.fgs @@ -0,0 +1,21 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = (2 ) mov r2, 0 ;JumpIfEqual 1 +use = (2 ) def = () in = (2 ) out = () cmp r2, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l0 ;JumpIfEqual 2 +use = () def = (3 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () jmp l1 ;Jump +use = () def = (4 ) in = () out = () l0 : mov eax, 0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (5 ) in = () out = () l1 : mov eax, 3 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/si5.fgs b/test/fgs-ref/si5.fgs new file mode 100644 index 0000000000000000000000000000000000000000..9f931ee449060c74b7d5a4e9b356631b1dd0bc8a --- /dev/null +++ b/test/fgs-ref/si5.fgs @@ -0,0 +1,33 @@ +iter num = 3 +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; code de sortie +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () push eax ;sauvegarde de eax +use = () def = () in = () out = () push ebx ;sauvegarde de ebx +use = () def = () in = () out = () push ecx ;sauvegarde de ecx +use = () def = () in = () out = () push edx ;sauvegarde de edx +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (7 ) in = () out = (7 ) mov r7, 1 ;JumpIfEqual 1 +use = (7 ) def = () in = (7 ) out = () cmp r7, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (8 ) in = () out = () mov eax, 1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (9 ) in = () out = (9 ) mov r9, 1 ;JumpIfEqual 1 +use = (9 ) def = () in = (9 ) out = () cmp r9, 0 ;on passe par un registre temporaire +use = () def = () in = () out = () je l3 ;JumpIfEqual 2 +use = () def = (10 ) in = () out = () mov eax, 2 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (11 ) in = () out = () l3 : mov eax, 3 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = (12 ) in = () out = () pop edx ;restaure edx +use = () def = (13 ) in = () out = () pop ecx ;restaure ecx +use = () def = (14 ) in = () out = () pop ebx ;restaure ebx +use = () def = (15 ) in = () out = () pop eax ;restaure eax +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/sub1.fgs b/test/fgs-ref/sub1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..5b3cd76ea7b44eb2f0d2e79a32f98a07e9bfa36a --- /dev/null +++ b/test/fgs-ref/sub1.fgs @@ -0,0 +1,15 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 10 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) sub r0, 5 ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/sub2.fgs b/test/fgs-ref/sub2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..cec410fe23922832e4e88d695f57c6a2b43febc4 --- /dev/null +++ b/test/fgs-ref/sub2.fgs @@ -0,0 +1,15 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 7 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) sub r0, 20 ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/sub3.fgs b/test/fgs-ref/sub3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..95d9b3599bce1afe2d417db9768a1cc1be0be15e --- /dev/null +++ b/test/fgs-ref/sub3.fgs @@ -0,0 +1,17 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (0 ) in = () out = (0 ) mov r0, 2 ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) sub r0, 1 ; +use = (0 ) def = (1 ) in = (0 ) out = (1 ) mov r1, r0 ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) sub r1, 1 ; +use = (1 ) def = (4 ) in = (1 ) out = () mov eax, r1 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/tab1.fgs b/test/fgs-ref/tab1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..231b91a430fc968b8b87a26ee703ac84272d7ac0 --- /dev/null +++ b/test/fgs-ref/tab1.fgs @@ -0,0 +1,26 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (2 ) in = () out = (2 ) mov r2, 0 ; +use = (2 ) def = () in = (2 ) out = () mov dword [tab+4*r2], 0 ;Affect +use = () def = (3 ) in = () out = (3 ) mov r3, 1 ; +use = (3 ) def = () in = (3 ) out = () mov dword [tab+4*r3], 1 ;Affect +use = () def = (4 ) in = () out = (4 ) mov r4, 2 ; +use = (4 ) def = () in = (4 ) out = () mov dword [tab+4*r4], 2 ;Affect +use = () def = (6 ) in = () out = (6 ) mov r6, 0 ; +use = (6 ) def = (5 ) in = (6 ) out = () mov eax, dword [tab+4*r6] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (8 ) in = () out = (8 ) mov r8, 1 ; +use = (8 ) def = (7 ) in = (8 ) out = () mov eax, dword [tab+4*r8] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (10 ) in = () out = (10 ) mov r10, 2 ; +use = (10 ) def = (9 ) in = (10 ) out = () mov eax, dword [tab+4*r10] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/tab2.fgs b/test/fgs-ref/tab2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..de80c1273167955ecd770a0e4083689cdc0ee294 --- /dev/null +++ b/test/fgs-ref/tab2.fgs @@ -0,0 +1,33 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (3 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (4 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 2 ;Affect +use = () def = (0 ) in = () out = (0 ) mov r0, dword [ebp-4*1] ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, 0 ; +use = (0 ) def = (5 ) in = (0 ) out = (5 ) mov r5, r0 ; +use = (5 ) def = () in = (5 ) out = () mov dword [tab+4*r5], 34 ;Affect +use = () def = (1 ) in = () out = (1 ) mov r1, dword [ebp-4*1] ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) add r1, 1 ; +use = (1 ) def = (6 ) in = (1 ) out = (6 ) mov r6, r1 ; +use = (6 ) def = () in = (6 ) out = () mov dword [tab+4*r6], 74 ;Affect +use = () def = (2 ) in = () out = (2 ) mov r2, dword [ebp-4*1] ; +use = (2 ) def = (2 ) in = (2 ) out = (2 ) add r2, 2 ; +use = (2 ) def = (7 ) in = (2 ) out = (7 ) mov r7, r2 ; +use = (7 ) def = () in = (7 ) out = () mov dword [tab+4*r7], 16 ;Affect +use = () def = (9 ) in = () out = (9 ) mov r9, 2 ; +use = (9 ) def = (8 ) in = (9 ) out = () mov eax, dword [tab+4*r9] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (11 ) in = () out = (11 ) mov r11, 3 ; +use = (11 ) def = (10 ) in = (11 ) out = () mov eax, dword [tab+4*r11] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (13 ) in = () out = (13 ) mov r13, 4 ; +use = (13 ) def = (12 ) in = (13 ) out = () mov eax, dword [tab+4*r13] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/tab3.fgs b/test/fgs-ref/tab3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..95adfbb99ed5c152e37d295cfecfe278d4938862 --- /dev/null +++ b/test/fgs-ref/tab3.fgs @@ -0,0 +1,36 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (3 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (4 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 8 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 2 ;Affect +use = () def = () in = () out = () mov dword [ebp-4*2], 0 ;Affect +use = () def = (0 ) in = () out = (0 ) mov r0, dword [ebp-4*1] ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, dword [ebp-4*2] ; +use = (0 ) def = (5 ) in = (0 ) out = (5 ) mov r5, r0 ; +use = (5 ) def = () in = (5 ) out = () mov dword [tab+4*r5], 34 ;Affect +use = () def = () in = () out = () mov dword [ebp-4*2], 1 ;Affect +use = () def = (1 ) in = () out = (1 ) mov r1, dword [ebp-4*1] ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) add r1, dword [ebp-4*2] ; +use = (1 ) def = (6 ) in = (1 ) out = (6 ) mov r6, r1 ; +use = (6 ) def = () in = (6 ) out = () mov dword [tab+4*r6], 74 ;Affect +use = () def = () in = () out = () mov dword [ebp-4*2], 2 ;Affect +use = () def = (2 ) in = () out = (2 ) mov r2, dword [ebp-4*1] ; +use = (2 ) def = (2 ) in = (2 ) out = (2 ) add r2, dword [ebp-4*2] ; +use = (2 ) def = (7 ) in = (2 ) out = (7 ) mov r7, r2 ; +use = (7 ) def = () in = (7 ) out = () mov dword [tab+4*r7], 16 ;Affect +use = () def = (9 ) in = () out = (9 ) mov r9, 2 ; +use = (9 ) def = (8 ) in = (9 ) out = () mov eax, dword [tab+4*r9] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (11 ) in = () out = (11 ) mov r11, 3 ; +use = (11 ) def = (10 ) in = (11 ) out = () mov eax, dword [tab+4*r11] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (13 ) in = () out = (13 ) mov r13, 4 ; +use = (13 ) def = (12 ) in = (13 ) out = () mov eax, dword [tab+4*r13] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 8 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/tab4.fgs b/test/fgs-ref/tab4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..c0d4f8ad14c4aed7f0572b184afc6af885d765a7 --- /dev/null +++ b/test/fgs-ref/tab4.fgs @@ -0,0 +1,30 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = (3 ) in = () out = (3 ) mov r3, 0 ; +use = (3 ) def = () in = (3 ) out = () mov dword [tab+4*r3], 1 ;Affect +use = () def = (5 ) in = () out = (5 ) mov r5, 0 ; +use = (5 ) def = (4 ) in = (5 ) out = (4 ) mov r4, dword [tab+4*r5] ; +use = (4 ) def = () in = (4 ) out = () mov dword [tab+4*r4], 12 ;Affect +use = () def = (6 ) in = () out = (6 ) mov r6, 0 ; +use = (6 ) def = (0 ) in = (6 ) out = (0 ) mov r0, dword [tab+4*r6] ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, 1 ; +use = (0 ) def = (7 ) in = (0 ) out = (7 ) mov r7, r0 ; +use = (7 ) def = () in = (7 ) out = () mov dword [tab+4*r7], 13 ;Affect +use = () def = (9 ) in = () out = (9 ) mov r9, 0 ; +use = (9 ) def = (8 ) in = (9 ) out = () mov eax, dword [tab+4*r9] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (11 ) in = () out = (11 ) mov r11, 1 ; +use = (11 ) def = (10 ) in = (11 ) out = () mov eax, dword [tab+4*r11] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (13 ) in = () out = (13 ) mov r13, 2 ; +use = (13 ) def = (12 ) in = (13 ) out = () mov eax, dword [tab+4*r13] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/tantque1.fgs b/test/fgs-ref/tantque1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..d7bf6e0d387e2d39e5be1a0061a2a52efc5c0cd8 --- /dev/null +++ b/test/fgs-ref/tantque1.fgs @@ -0,0 +1,27 @@ +iter num = 9 +use = () def = () in = () out = () call main ; +use = () def = (2 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (3 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 10 ;Affect +use = () def = (0 ) in = () out = (0 ) l0 : mov r0, 1 ;Affect +use = () def = (4 ) in = (0 ) out = (0 4 ) mov r4, 0 ;JumpIfLess 1 +use = (4 ) def = () in = (0 4 ) out = (0 ) cmp r4, dword [ebp-4*1] ;on passe par un registre temporaire +use = () def = () in = (0 ) out = (0 ) jl l2 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = () in = (0 ) out = () l2 : cmp r0, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = (5 ) in = () out = () mov eax, dword [ebp-4*1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (1 ) in = () out = (1 ) mov r1, dword [ebp-4*1] ; +use = (1 ) def = (1 ) in = (1 ) out = (1 ) sub r1, 1 ; +use = (1 ) def = () in = (1 ) out = () mov dword [ebp-4*1], r1 ;Affect +use = () def = () in = () out = () jmp l0 ;Jump +use = () def = (6 ) in = () out = () l1 : mov eax, 0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/tantque2.fgs b/test/fgs-ref/tantque2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..279c4dfa7e0a47ec52d6ae2b1a470c5e81e695ca --- /dev/null +++ b/test/fgs-ref/tantque2.fgs @@ -0,0 +1,37 @@ +iter num = 7 +use = () def = () in = () out = () call main ; +use = () def = (4 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (5 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 8 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 0 ;Affect +use = () def = (0 ) in = () out = (0 ) l0 : mov r0, 1 ;Affect +use = () def = () in = (0 ) out = (0 ) cmp dword [ebp-4*1], 4 ;JumpIfLess 1 +use = () def = () in = (0 ) out = (0 ) jl l2 ;JumpIfLess 2 +use = () def = (0 ) in = () out = (0 ) mov r0, 0 ;Affect +use = (0 ) def = () in = (0 ) out = () l2 : cmp r0, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l1 ;JumpIfEqual 2 +use = () def = () in = () out = () mov dword [ebp-4*2], 0 ;Affect +use = () def = (1 ) in = () out = (1 ) l3 : mov r1, 1 ;Affect +use = () def = () in = (1 ) out = (1 ) cmp dword [ebp-4*2], 4 ;JumpIfLess 1 +use = () def = () in = (1 ) out = (1 ) jl l5 ;JumpIfLess 2 +use = () def = (1 ) in = () out = (1 ) mov r1, 0 ;Affect +use = (1 ) def = () in = (1 ) out = () l5 : cmp r1, 0 ;JumpIfEqual 1 +use = () def = () in = () out = () je l4 ;JumpIfEqual 2 +use = () def = (6 ) in = () out = () mov eax, dword [ebp-4*1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (7 ) in = () out = () mov eax, dword [ebp-4*2] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (2 ) in = () out = (2 ) mov r2, dword [ebp-4*2] ; +use = (2 ) def = (2 ) in = (2 ) out = (2 ) add r2, 1 ; +use = (2 ) def = () in = (2 ) out = () mov dword [ebp-4*2], r2 ;Affect +use = () def = () in = () out = () jmp l3 ;Jump +use = () def = (3 ) in = () out = (3 ) l4 : mov r3, dword [ebp-4*1] ; +use = (3 ) def = (3 ) in = (3 ) out = (3 ) add r3, 1 ; +use = (3 ) def = () in = (3 ) out = () mov dword [ebp-4*1], r3 ;Affect +use = () def = () in = () out = () jmp l0 ;Jump +use = () def = () in = () out = () l1 : add esp, 8 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varglob1.fgs b/test/fgs-ref/varglob1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..72148c7bdc6342700cbf03de513ef3c9b0bb1083 --- /dev/null +++ b/test/fgs-ref/varglob1.fgs @@ -0,0 +1,14 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () mov dword [variable], 6834 ;Affect +use = () def = (2 ) in = () out = () mov eax, dword [variable] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varglob2.fgs b/test/fgs-ref/varglob2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..b4190b6dbe9f8233d7fc10e522dd5bbe78a64b7b --- /dev/null +++ b/test/fgs-ref/varglob2.fgs @@ -0,0 +1,16 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () mov dword [variable], 10 ;Affect +use = () def = (0 ) in = () out = (0 ) mov r0, dword [variable] ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, 50 ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varglob3.fgs b/test/fgs-ref/varglob3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..35eebac1b9fa24d0f086cd3f0bc37e5391c1119a --- /dev/null +++ b/test/fgs-ref/varglob3.fgs @@ -0,0 +1,17 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () mov dword [var1], 10 ;Affect +use = () def = () in = () out = () mov dword [var2], 34 ;Affect +use = () def = (2 ) in = () out = () mov eax, dword [var1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (3 ) in = () out = () mov eax, dword [var2] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varglob4.fgs b/test/fgs-ref/varglob4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..6405a6f21615c5ceb085870025b307840d6b60fa --- /dev/null +++ b/test/fgs-ref/varglob4.fgs @@ -0,0 +1,17 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () mov dword [var1], 10 ;Affect +use = () def = () in = () out = () mov dword [var2], 34 ;Affect +use = () def = (0 ) in = () out = (0 ) mov r0, dword [var1] ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, dword [var2] ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varloc1.fgs b/test/fgs-ref/varloc1.fgs new file mode 100644 index 0000000000000000000000000000000000000000..591bef11e8dba7b96c15557ea036110fe431ff9b --- /dev/null +++ b/test/fgs-ref/varloc1.fgs @@ -0,0 +1,14 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 6834 ;Affect +use = () def = (2 ) in = () out = () mov eax, dword [ebp-4*1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varloc2.fgs b/test/fgs-ref/varloc2.fgs new file mode 100644 index 0000000000000000000000000000000000000000..3d7d2c72751b998bf20363cb66c8e97e20479573 --- /dev/null +++ b/test/fgs-ref/varloc2.fgs @@ -0,0 +1,16 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 10 ;Affect +use = () def = (0 ) in = () out = (0 ) mov r0, dword [ebp-4*1] ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, 50 ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varloc3.fgs b/test/fgs-ref/varloc3.fgs new file mode 100644 index 0000000000000000000000000000000000000000..e38d5724c463ef3549a0c360fa8b10f9a06ebc0b --- /dev/null +++ b/test/fgs-ref/varloc3.fgs @@ -0,0 +1,17 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (0 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (1 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 8 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 10 ;Affect +use = () def = () in = () out = () mov dword [ebp-4*2], 30 ;Affect +use = () def = (2 ) in = () out = () mov eax, dword [ebp-4*1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = (3 ) in = () out = () mov eax, dword [ebp-4*2] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 8 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varloc4.fgs b/test/fgs-ref/varloc4.fgs new file mode 100644 index 0000000000000000000000000000000000000000..0357bacf680ceebf6184b737536124486a4f5431 --- /dev/null +++ b/test/fgs-ref/varloc4.fgs @@ -0,0 +1,17 @@ +iter num = 3 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 8 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 10 ;Affect +use = () def = () in = () out = () mov dword [ebp-4*2], 30 ;Affect +use = () def = (0 ) in = () out = (0 ) mov r0, dword [ebp-4*1] ; +use = (0 ) def = (0 ) in = (0 ) out = (0 ) add r0, dword [ebp-4*2] ; +use = (0 ) def = (3 ) in = (0 ) out = () mov eax, r0 ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 8 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/fgs-ref/varloc5.fgs b/test/fgs-ref/varloc5.fgs new file mode 100644 index 0000000000000000000000000000000000000000..74ee639cf0e1cca87d87ac21552afc3b123a218c --- /dev/null +++ b/test/fgs-ref/varloc5.fgs @@ -0,0 +1,26 @@ +iter num = 1 +use = () def = () in = () out = () call main ; +use = () def = (1 ) in = () out = () mov ebx, 0 ; valeur de retour du programme +use = () def = (2 ) in = () out = () mov eax, 1 ; +use = () def = () in = () out = () int 0x80 ; +use = () def = () in = () out = () f : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 4 ;allocation des variables locales +use = () def = () in = () out = () mov dword [ebp-4*1], 10 ;Affect +use = () def = (3 ) in = () out = () mov eax, dword [ebp-4*1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 4 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; +use = () def = () in = () out = () main : push ebp ;sauvegarde la valeur de ebp +use = () def = () in = () out = () mov ebp, esp ;nouvelle valeur de ebp +use = () def = () in = () out = () sub esp, 0 ;allocation des variables locales +use = () def = () in = () out = () mov dword [var1], 20 ;Affect +use = () def = () in = () out = () sub esp, 4 ;allocation mémoire pour la valeur de retour +use = () def = () in = () out = () call f ; +use = () def = (0 ) in = () out = () pop r0 ;récupération de la valeur de retour +use = () def = (4 ) in = () out = () mov eax, dword [var1] ;Write 1 +use = () def = () in = () out = () call iprintLF ;Write 2 +use = () def = () in = () out = () add esp, 0 ;désallocation des variables locales +use = () def = () in = () out = () pop ebp ;restaure la valeur de ebp +use = () def = () in = () out = () ret ; diff --git a/test/ig-ref/add1.ig b/test/ig-ref/add1.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/add1.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/add2.ig b/test/ig-ref/add2.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/add2.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/affect1.ig b/test/ig-ref/affect1.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/affect1.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/affect2.ig b/test/ig-ref/affect2.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/affect2.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/affect3.ig b/test/ig-ref/affect3.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/affect3.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/and1.ig b/test/ig-ref/and1.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/and1.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/and2.ig b/test/ig-ref/and2.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/and2.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/and3.ig b/test/ig-ref/and3.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/and3.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/and4.ig b/test/ig-ref/and4.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/and4.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/and5.ig b/test/ig-ref/and5.ig new file mode 100644 index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb --- /dev/null +++ b/test/ig-ref/and5.ig @@ -0,0 +1,8 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) diff --git a/test/ig-ref/appel-param1.ig b/test/ig-ref/appel-param1.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/appel-param1.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/appel-param2.ig b/test/ig-ref/appel-param2.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/appel-param2.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/appel-param3.ig b/test/ig-ref/appel-param3.ig new file mode 100644 index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb --- /dev/null +++ b/test/ig-ref/appel-param3.ig @@ -0,0 +1,8 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) diff --git a/test/ig-ref/appel-retour1.ig b/test/ig-ref/appel-retour1.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/appel-retour1.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/appel1.ig b/test/ig-ref/appel1.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/appel1.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/appel2.ig b/test/ig-ref/appel2.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/appel2.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/appel3.ig b/test/ig-ref/appel3.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/appel3.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/div1.ig b/test/ig-ref/div1.ig new file mode 100644 index 0000000000000000000000000000000000000000..310c1f52237446d24253ea03f0be444fccdced19 --- /dev/null +++ b/test/ig-ref/div1.ig @@ -0,0 +1,7 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( 5 ) +5 : ( 4 ) +6 : ( ) diff --git a/test/ig-ref/div2.ig b/test/ig-ref/div2.ig new file mode 100644 index 0000000000000000000000000000000000000000..310c1f52237446d24253ea03f0be444fccdced19 --- /dev/null +++ b/test/ig-ref/div2.ig @@ -0,0 +1,7 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( 5 ) +5 : ( 4 ) +6 : ( ) diff --git a/test/ig-ref/div3.ig b/test/ig-ref/div3.ig new file mode 100644 index 0000000000000000000000000000000000000000..cc8980121196af577980067b44c059fc2f0e0984 --- /dev/null +++ b/test/ig-ref/div3.ig @@ -0,0 +1,11 @@ +0 : ( 9 ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( 9 6 ) +6 : ( 5 9 ) +7 : ( ) +8 : ( 9 ) +9 : ( 8 0 5 6 ) +10 : ( ) diff --git a/test/ig-ref/div4.ig b/test/ig-ref/div4.ig new file mode 100644 index 0000000000000000000000000000000000000000..310c1f52237446d24253ea03f0be444fccdced19 --- /dev/null +++ b/test/ig-ref/div4.ig @@ -0,0 +1,7 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( 5 ) +5 : ( 4 ) +6 : ( ) diff --git a/test/ig-ref/ecrire1.ig b/test/ig-ref/ecrire1.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/ecrire1.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/ecrire2.ig b/test/ig-ref/ecrire2.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/ecrire2.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/egal1.ig b/test/ig-ref/egal1.ig new file mode 100644 index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f --- /dev/null +++ b/test/ig-ref/egal1.ig @@ -0,0 +1,5 @@ +0 : ( 3 ) +1 : ( ) +2 : ( ) +3 : ( 0 ) +4 : ( ) diff --git a/test/ig-ref/egal2.ig b/test/ig-ref/egal2.ig new file mode 100644 index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f --- /dev/null +++ b/test/ig-ref/egal2.ig @@ -0,0 +1,5 @@ +0 : ( 3 ) +1 : ( ) +2 : ( ) +3 : ( 0 ) +4 : ( ) diff --git a/test/ig-ref/egal3.ig b/test/ig-ref/egal3.ig new file mode 100644 index 0000000000000000000000000000000000000000..36be12eb5627b51d48d81355f8271b213dba6a54 --- /dev/null +++ b/test/ig-ref/egal3.ig @@ -0,0 +1,6 @@ +0 : ( 1 ) +1 : ( 0 4 ) +2 : ( ) +3 : ( ) +4 : ( 1 ) +5 : ( ) diff --git a/test/ig-ref/err5.ig b/test/ig-ref/err5.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/err5.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/fibo.ig b/test/ig-ref/fibo.ig new file mode 100644 index 0000000000000000000000000000000000000000..995a6d6c7c53e0bc9dade0852ee98696d6fdb389 --- /dev/null +++ b/test/ig-ref/fibo.ig @@ -0,0 +1,35 @@ +0 : ( ) +1 : ( ) +2 : ( 4 5 ) +3 : ( ) +4 : ( 6 2 ) +5 : ( 2 ) +6 : ( 4 ) +7 : ( ) +8 : ( ) +9 : ( ) +10 : ( ) +11 : ( ) +12 : ( ) +13 : ( ) +14 : ( ) +15 : ( ) +16 : ( ) +17 : ( ) +18 : ( ) +19 : ( ) +20 : ( ) +21 : ( ) +22 : ( ) +23 : ( ) +24 : ( ) +25 : ( ) +26 : ( ) +27 : ( ) +28 : ( ) +29 : ( ) +30 : ( ) +31 : ( ) +32 : ( ) +33 : ( ) +34 : ( ) diff --git a/test/ig-ref/inf1.ig b/test/ig-ref/inf1.ig new file mode 100644 index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f --- /dev/null +++ b/test/ig-ref/inf1.ig @@ -0,0 +1,5 @@ +0 : ( 3 ) +1 : ( ) +2 : ( ) +3 : ( 0 ) +4 : ( ) diff --git a/test/ig-ref/inf2.ig b/test/ig-ref/inf2.ig new file mode 100644 index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f --- /dev/null +++ b/test/ig-ref/inf2.ig @@ -0,0 +1,5 @@ +0 : ( 3 ) +1 : ( ) +2 : ( ) +3 : ( 0 ) +4 : ( ) diff --git a/test/ig-ref/inf3.ig b/test/ig-ref/inf3.ig new file mode 100644 index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f --- /dev/null +++ b/test/ig-ref/inf3.ig @@ -0,0 +1,5 @@ +0 : ( 3 ) +1 : ( ) +2 : ( ) +3 : ( 0 ) +4 : ( ) diff --git a/test/ig-ref/inf4.ig b/test/ig-ref/inf4.ig new file mode 100644 index 0000000000000000000000000000000000000000..36be12eb5627b51d48d81355f8271b213dba6a54 --- /dev/null +++ b/test/ig-ref/inf4.ig @@ -0,0 +1,6 @@ +0 : ( 1 ) +1 : ( 0 4 ) +2 : ( ) +3 : ( ) +4 : ( 1 ) +5 : ( ) diff --git a/test/ig-ref/mult1.ig b/test/ig-ref/mult1.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/mult1.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/mult2.ig b/test/ig-ref/mult2.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/mult2.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/mult3.ig b/test/ig-ref/mult3.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/mult3.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/not1.ig b/test/ig-ref/not1.ig new file mode 100644 index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f --- /dev/null +++ b/test/ig-ref/not1.ig @@ -0,0 +1,5 @@ +0 : ( 3 ) +1 : ( ) +2 : ( ) +3 : ( 0 ) +4 : ( ) diff --git a/test/ig-ref/not2.ig b/test/ig-ref/not2.ig new file mode 100644 index 0000000000000000000000000000000000000000..409eea47c542539000a70be92be6c7179347f86f --- /dev/null +++ b/test/ig-ref/not2.ig @@ -0,0 +1,5 @@ +0 : ( 3 ) +1 : ( ) +2 : ( ) +3 : ( 0 ) +4 : ( ) diff --git a/test/ig-ref/not3.ig b/test/ig-ref/not3.ig new file mode 100644 index 0000000000000000000000000000000000000000..36be12eb5627b51d48d81355f8271b213dba6a54 --- /dev/null +++ b/test/ig-ref/not3.ig @@ -0,0 +1,6 @@ +0 : ( 1 ) +1 : ( 0 4 ) +2 : ( ) +3 : ( ) +4 : ( 1 ) +5 : ( ) diff --git a/test/ig-ref/or1.ig b/test/ig-ref/or1.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/or1.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/or2.ig b/test/ig-ref/or2.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/or2.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/or3.ig b/test/ig-ref/or3.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/or3.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/or4.ig b/test/ig-ref/or4.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/or4.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/or5.ig b/test/ig-ref/or5.ig new file mode 100644 index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb --- /dev/null +++ b/test/ig-ref/or5.ig @@ -0,0 +1,8 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) diff --git a/test/ig-ref/parenth1.ig b/test/ig-ref/parenth1.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/parenth1.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/parenth2.ig b/test/ig-ref/parenth2.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/parenth2.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/prio23-1.ig b/test/ig-ref/prio23-1.ig new file mode 100644 index 0000000000000000000000000000000000000000..01906f1f55c7e72f8ab7d976cf8fcc17186c563e --- /dev/null +++ b/test/ig-ref/prio23-1.ig @@ -0,0 +1,6 @@ +0 : ( 4 ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( 0 ) +5 : ( ) diff --git a/test/ig-ref/prio23-2.ig b/test/ig-ref/prio23-2.ig new file mode 100644 index 0000000000000000000000000000000000000000..3c4608482365a6a21e9ccf6dc11524a3c9ce5d2f --- /dev/null +++ b/test/ig-ref/prio23-2.ig @@ -0,0 +1,6 @@ +0 : ( 1 4 ) +1 : ( 0 ) +2 : ( ) +3 : ( ) +4 : ( 0 ) +5 : ( ) diff --git a/test/ig-ref/prio23-3.ig b/test/ig-ref/prio23-3.ig new file mode 100644 index 0000000000000000000000000000000000000000..2c85526956fe487ca5073e4bd388a8297976f676 --- /dev/null +++ b/test/ig-ref/prio23-3.ig @@ -0,0 +1,9 @@ +0 : ( 4 7 ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( 7 0 ) +5 : ( ) +6 : ( 7 ) +7 : ( 6 4 0 ) +8 : ( ) diff --git a/test/ig-ref/prio23-4.ig b/test/ig-ref/prio23-4.ig new file mode 100644 index 0000000000000000000000000000000000000000..a6f011454e01399e9487896d2684cc3b60098e93 --- /dev/null +++ b/test/ig-ref/prio23-4.ig @@ -0,0 +1,10 @@ +0 : ( 6 1 5 8 ) +1 : ( 6 8 0 ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( 8 0 ) +6 : ( 8 1 0 ) +7 : ( ) +8 : ( 6 1 5 0 ) +9 : ( ) diff --git a/test/ig-ref/prio34-1.ig b/test/ig-ref/prio34-1.ig new file mode 100644 index 0000000000000000000000000000000000000000..651a70ae35d31e64b15f791a512dc38bacc8d4b5 --- /dev/null +++ b/test/ig-ref/prio34-1.ig @@ -0,0 +1,5 @@ +0 : ( 1 ) +1 : ( 0 ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/prio34-2.ig b/test/ig-ref/prio34-2.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/prio34-2.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/prio34-3.ig b/test/ig-ref/prio34-3.ig new file mode 100644 index 0000000000000000000000000000000000000000..896201f0cf276a33d3eacdda3e9efe03ece0118d --- /dev/null +++ b/test/ig-ref/prio34-3.ig @@ -0,0 +1,8 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( 6 ) +6 : ( 5 ) +7 : ( ) diff --git a/test/ig-ref/prio34-4.ig b/test/ig-ref/prio34-4.ig new file mode 100644 index 0000000000000000000000000000000000000000..160bcbd72aa91b0df143036726fcd2a5e96bffb0 --- /dev/null +++ b/test/ig-ref/prio34-4.ig @@ -0,0 +1,8 @@ +0 : ( 1 ) +1 : ( 0 ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( 6 ) +6 : ( 5 ) +7 : ( ) diff --git a/test/ig-ref/prio45-1.ig b/test/ig-ref/prio45-1.ig new file mode 100644 index 0000000000000000000000000000000000000000..3e687894c32f2e6bd4825a4c5b748f70ba2d2ab2 --- /dev/null +++ b/test/ig-ref/prio45-1.ig @@ -0,0 +1,6 @@ +0 : ( 4 1 ) +1 : ( 4 0 ) +2 : ( ) +3 : ( ) +4 : ( 1 0 ) +5 : ( ) diff --git a/test/ig-ref/prio45-2.ig b/test/ig-ref/prio45-2.ig new file mode 100644 index 0000000000000000000000000000000000000000..651a70ae35d31e64b15f791a512dc38bacc8d4b5 --- /dev/null +++ b/test/ig-ref/prio45-2.ig @@ -0,0 +1,5 @@ +0 : ( 1 ) +1 : ( 0 ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/prio45-3.ig b/test/ig-ref/prio45-3.ig new file mode 100644 index 0000000000000000000000000000000000000000..3e687894c32f2e6bd4825a4c5b748f70ba2d2ab2 --- /dev/null +++ b/test/ig-ref/prio45-3.ig @@ -0,0 +1,6 @@ +0 : ( 4 1 ) +1 : ( 4 0 ) +2 : ( ) +3 : ( ) +4 : ( 1 0 ) +5 : ( ) diff --git a/test/ig-ref/prio45-4.ig b/test/ig-ref/prio45-4.ig new file mode 100644 index 0000000000000000000000000000000000000000..651a70ae35d31e64b15f791a512dc38bacc8d4b5 --- /dev/null +++ b/test/ig-ref/prio45-4.ig @@ -0,0 +1,5 @@ +0 : ( 1 ) +1 : ( 0 ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/prio56-1.ig b/test/ig-ref/prio56-1.ig new file mode 100644 index 0000000000000000000000000000000000000000..5a5fe88d2b8713ca0818b3216664adad7e480337 --- /dev/null +++ b/test/ig-ref/prio56-1.ig @@ -0,0 +1,7 @@ +0 : ( ) +1 : ( 4 ) +2 : ( ) +3 : ( ) +4 : ( 1 ) +5 : ( ) +6 : ( ) diff --git a/test/ig-ref/prio56-2.ig b/test/ig-ref/prio56-2.ig new file mode 100644 index 0000000000000000000000000000000000000000..70471f118d22beab077a89cbf75d2fcfaa4ba798 --- /dev/null +++ b/test/ig-ref/prio56-2.ig @@ -0,0 +1,7 @@ +0 : ( ) +1 : ( 5 4 ) +2 : ( ) +3 : ( ) +4 : ( 1 ) +5 : ( 1 ) +6 : ( ) diff --git a/test/ig-ref/prio67-1.ig b/test/ig-ref/prio67-1.ig new file mode 100644 index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb --- /dev/null +++ b/test/ig-ref/prio67-1.ig @@ -0,0 +1,8 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) diff --git a/test/ig-ref/prio67-2.ig b/test/ig-ref/prio67-2.ig new file mode 100644 index 0000000000000000000000000000000000000000..2ca8a442005ac51bade93e80883a9cc18ee6adef --- /dev/null +++ b/test/ig-ref/prio67-2.ig @@ -0,0 +1,8 @@ +0 : ( ) +1 : ( 6 ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( 1 ) +7 : ( ) diff --git a/test/ig-ref/rec1.ig b/test/ig-ref/rec1.ig new file mode 100644 index 0000000000000000000000000000000000000000..38c4a8b116aab938ff6e5db9c416184b14668c20 --- /dev/null +++ b/test/ig-ref/rec1.ig @@ -0,0 +1,33 @@ +0 : ( ) +1 : ( ) +2 : ( 4 ) +3 : ( ) +4 : ( 2 ) +5 : ( ) +6 : ( ) +7 : ( ) +8 : ( ) +9 : ( ) +10 : ( ) +11 : ( ) +12 : ( ) +13 : ( ) +14 : ( ) +15 : ( ) +16 : ( ) +17 : ( ) +18 : ( ) +19 : ( ) +20 : ( ) +21 : ( ) +22 : ( ) +23 : ( ) +24 : ( ) +25 : ( ) +26 : ( ) +27 : ( ) +28 : ( ) +29 : ( ) +30 : ( ) +31 : ( ) +32 : ( ) diff --git a/test/ig-ref/si1.ig b/test/ig-ref/si1.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/si1.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/si2.ig b/test/ig-ref/si2.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/si2.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/si3.ig b/test/ig-ref/si3.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/si3.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/si4.ig b/test/ig-ref/si4.ig new file mode 100644 index 0000000000000000000000000000000000000000..9fbbbabf623bdaea697ff52c278325ce84aaf146 --- /dev/null +++ b/test/ig-ref/si4.ig @@ -0,0 +1,6 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) diff --git a/test/ig-ref/si5.ig b/test/ig-ref/si5.ig new file mode 100644 index 0000000000000000000000000000000000000000..99b007eb14bfb050424a6bc809dd2c923f84dd00 --- /dev/null +++ b/test/ig-ref/si5.ig @@ -0,0 +1,16 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) +8 : ( ) +9 : ( ) +10 : ( ) +11 : ( ) +12 : ( ) +13 : ( ) +14 : ( ) +15 : ( ) diff --git a/test/ig-ref/sub1.ig b/test/ig-ref/sub1.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/sub1.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/sub2.ig b/test/ig-ref/sub2.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/sub2.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/sub3.ig b/test/ig-ref/sub3.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/sub3.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/ig-ref/tab1.ig b/test/ig-ref/tab1.ig new file mode 100644 index 0000000000000000000000000000000000000000..296dc402e4beb908d25e1edd7925f7f29ccff47f --- /dev/null +++ b/test/ig-ref/tab1.ig @@ -0,0 +1,11 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) +8 : ( ) +9 : ( ) +10 : ( ) diff --git a/test/ig-ref/tab2.ig b/test/ig-ref/tab2.ig new file mode 100644 index 0000000000000000000000000000000000000000..3687f68368a1820984f5f6e790e0d15c40840028 --- /dev/null +++ b/test/ig-ref/tab2.ig @@ -0,0 +1,14 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) +8 : ( ) +9 : ( ) +10 : ( ) +11 : ( ) +12 : ( ) +13 : ( ) diff --git a/test/ig-ref/tab3.ig b/test/ig-ref/tab3.ig new file mode 100644 index 0000000000000000000000000000000000000000..3687f68368a1820984f5f6e790e0d15c40840028 --- /dev/null +++ b/test/ig-ref/tab3.ig @@ -0,0 +1,14 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) +8 : ( ) +9 : ( ) +10 : ( ) +11 : ( ) +12 : ( ) +13 : ( ) diff --git a/test/ig-ref/tab4.ig b/test/ig-ref/tab4.ig new file mode 100644 index 0000000000000000000000000000000000000000..3687f68368a1820984f5f6e790e0d15c40840028 --- /dev/null +++ b/test/ig-ref/tab4.ig @@ -0,0 +1,14 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) +8 : ( ) +9 : ( ) +10 : ( ) +11 : ( ) +12 : ( ) +13 : ( ) diff --git a/test/ig-ref/tantque1.ig b/test/ig-ref/tantque1.ig new file mode 100644 index 0000000000000000000000000000000000000000..95f1f946f2e59761b04b01a0d18ef449f8df821d --- /dev/null +++ b/test/ig-ref/tantque1.ig @@ -0,0 +1,7 @@ +0 : ( 4 ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( 0 ) +5 : ( ) +6 : ( ) diff --git a/test/ig-ref/tantque2.ig b/test/ig-ref/tantque2.ig new file mode 100644 index 0000000000000000000000000000000000000000..b8523b93b4678fa9e24a1991fe05a4bfca85bffb --- /dev/null +++ b/test/ig-ref/tantque2.ig @@ -0,0 +1,8 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) +5 : ( ) +6 : ( ) +7 : ( ) diff --git a/test/ig-ref/varglob1.ig b/test/ig-ref/varglob1.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/varglob1.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/varglob2.ig b/test/ig-ref/varglob2.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/varglob2.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/varglob3.ig b/test/ig-ref/varglob3.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/varglob3.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/varglob4.ig b/test/ig-ref/varglob4.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/varglob4.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/varloc1.ig b/test/ig-ref/varloc1.ig new file mode 100644 index 0000000000000000000000000000000000000000..9081252ca9b2e70a1032832c285b5dd17faaacac --- /dev/null +++ b/test/ig-ref/varloc1.ig @@ -0,0 +1,3 @@ +0 : ( ) +1 : ( ) +2 : ( ) diff --git a/test/ig-ref/varloc2.ig b/test/ig-ref/varloc2.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/varloc2.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/varloc3.ig b/test/ig-ref/varloc3.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/varloc3.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/varloc4.ig b/test/ig-ref/varloc4.ig new file mode 100644 index 0000000000000000000000000000000000000000..3ac5b32186535ec9c35893152bb8ea0e92977c32 --- /dev/null +++ b/test/ig-ref/varloc4.ig @@ -0,0 +1,4 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) diff --git a/test/ig-ref/varloc5.ig b/test/ig-ref/varloc5.ig new file mode 100644 index 0000000000000000000000000000000000000000..858571f62dd3e64754ad177d498b78373ec2ec06 --- /dev/null +++ b/test/ig-ref/varloc5.ig @@ -0,0 +1,5 @@ +0 : ( ) +1 : ( ) +2 : ( ) +3 : ( ) +4 : ( ) diff --git a/test/input/.gitignore b/test/input/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..970de746fd38aed52f8d16ed8bc89c2f8ef771f5 --- /dev/null +++ b/test/input/.gitignore @@ -0,0 +1,17 @@ +*\.sc +*\.sa +*\.saout +*\.ts +*\.c3a +*\.c3aout +*\.pre-nasm +*\.pre-nasmout +*\.fg +*\.fgs +*\.ig +*\.nasm +*\.nasmout +*\.exe +*\.exeout +*\.out +*\.o diff --git a/test/input/add1.l b/test/input/add1.l new file mode 100644 index 0000000000000000000000000000000000000000..ba8054139b94f7cae4cb2823d6ba74bf09c7c396 --- /dev/null +++ b/test/input/add1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(3 + 10); +} diff --git a/test/input/add1.s b/test/input/add1.s new file mode 100644 index 0000000000000000000000000000000000000000..e37fb3417dfdd67027603525d88fe6ed918643ce --- /dev/null +++ b/test/input/add1.s @@ -0,0 +1,20 @@ +.include "io_arm.asm" + + +.data + +.text +.global _start +_start: + bl main + mov r7, #1 //exit syscall + svc #0 //Syscall +main : push {r11,r14} //prologue func + mov r0, #3 + add r0, r0, #10 + push {r7,r14} //Sauvegarde r7 et lr + mov r7, #4 //Write syscall + svc #0 //syscall + pop {r7,r15} //Restauration de r7 et pc + pop {r11,r15} //epilogue func + bx lr diff --git a/test/input/add2.l b/test/input/add2.l new file mode 100644 index 0000000000000000000000000000000000000000..7f179b25a0dafae25fc1448c7e8e9be6566d0eae --- /dev/null +++ b/test/input/add2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 + 4 + 8); +} diff --git a/test/input/add2.s b/test/input/add2.s new file mode 100644 index 0000000000000000000000000000000000000000..308cfa2b0d03c2dcbc19fcc8bcdeb75eacd739ac --- /dev/null +++ b/test/input/add2.s @@ -0,0 +1,21 @@ +.include "io_arm.asm" + + +.data + +.text +.global _start +_start: + bl main + mov r7, #1 //exit syscall + svc #0 //Syscall +main : push {r11,r14} //prologue func + mov r1, #2 + add r1, r1, #4 + add r0, r2, #8 + push {r7,r14} //Sauvegarde r7 et lr + mov r7, #4 //Write syscall + svc #0 //syscall + pop {r7,r15} //Restauration de r7 et pc + pop {r11,r15} //epilogue func + bx lr diff --git a/test/input/affect1.l b/test/input/affect1.l new file mode 100644 index 0000000000000000000000000000000000000000..cff6425361c46fc4201ec50c467136911a31df37 --- /dev/null +++ b/test/input/affect1.l @@ -0,0 +1,6 @@ +entier a +main() +{ +a = 1; +ecrire(a); +} diff --git a/test/input/affect1.s b/test/input/affect1.s new file mode 100644 index 0000000000000000000000000000000000000000..bc095811a0185d396942f0e86fe11f35e07b3dd3 --- /dev/null +++ b/test/input/affect1.s @@ -0,0 +1,22 @@ +.include "io_arm.asm" + + +.data + +.global a +a:.worda VAR 1 0 + +.text +.global _start +_start: + bl main + mov r7, #1 //exit syscall + svc #0 //Syscall +main : push {r11,r14} //prologue func + mov a, #1 //Affect + push {r7,r14} //Sauvegarde r7 et lr + mov r7, #4 //Write syscall + svc #0 //syscall + pop {r7,r15} //Restauration de r7 et pc + pop {r11,r15} //epilogue func + bx lr diff --git a/test/input/affect2.l b/test/input/affect2.l new file mode 100644 index 0000000000000000000000000000000000000000..06a3ae489044b32b1e929fbb08b9488130ddf538 --- /dev/null +++ b/test/input/affect2.l @@ -0,0 +1,6 @@ +main() +entier a +{ +a = 1; +ecrire(a); +} diff --git a/test/input/affect2.s b/test/input/affect2.s new file mode 100644 index 0000000000000000000000000000000000000000..91743b4d1d4fbffb6a48849bb5b8aaf6ae654ff0 --- /dev/null +++ b/test/input/affect2.s @@ -0,0 +1,19 @@ +.include "io_arm.asm" + + +.data + +.text +.global _start +_start: + bl main + mov r7, #1 //exit syscall + svc #0 //Syscall +main : push {r11,r14} //prologue func + mov r0, #1 //Affect + push {r7,r14} //Sauvegarde r7 et lr + mov r7, #4 //Write syscall + svc #0 //syscall + pop {r7,r15} //Restauration de r7 et pc + pop {r11,r15} //epilogue func + bx lr diff --git a/test/input/affect3.l b/test/input/affect3.l new file mode 100644 index 0000000000000000000000000000000000000000..cb1da143fa8f7f0d4d329ed8ee4ca2285cf9a8ff --- /dev/null +++ b/test/input/affect3.l @@ -0,0 +1,11 @@ +f(entier a) +{ +a = 1; +ecrire(a); +} + +main() +entier a +{ +f(3); +} diff --git a/test/input/and1.l b/test/input/and1.l new file mode 100644 index 0000000000000000000000000000000000000000..722352f47492fad418cd756be210c096a4349659 --- /dev/null +++ b/test/input/and1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai & vrai); +} diff --git a/test/input/and2.l b/test/input/and2.l new file mode 100644 index 0000000000000000000000000000000000000000..7f27e0bdcea4de004c0f890e6db8052b40d6a99d --- /dev/null +++ b/test/input/and2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai & faux); +} diff --git a/test/input/and3.l b/test/input/and3.l new file mode 100644 index 0000000000000000000000000000000000000000..8b824bf16aab9f72185824317a4abbf0d686974c --- /dev/null +++ b/test/input/and3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(faux & vrai); +} diff --git a/test/input/and4.l b/test/input/and4.l new file mode 100644 index 0000000000000000000000000000000000000000..015b9dd2986fbec9f67b1668d25a854828ba27dc --- /dev/null +++ b/test/input/and4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(faux & faux); +} diff --git a/test/input/and5.l b/test/input/and5.l new file mode 100644 index 0000000000000000000000000000000000000000..b32c729a88b8933325a9c25b89f18d727b54222f --- /dev/null +++ b/test/input/and5.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai & faux & vrai); +} diff --git a/test/input/appel-param1.l b/test/input/appel-param1.l new file mode 100644 index 0000000000000000000000000000000000000000..3856000c925142720415e13c2cb9daf25484830b --- /dev/null +++ b/test/input/appel-param1.l @@ -0,0 +1,9 @@ +f(entier a) +{ +ecrire(a); +} + +main() +{ +f(1); +} diff --git a/test/input/appel-param2.l b/test/input/appel-param2.l new file mode 100644 index 0000000000000000000000000000000000000000..5278f1a08b8a8db0830aa2e83ddcaa84e1f2e1eb --- /dev/null +++ b/test/input/appel-param2.l @@ -0,0 +1,10 @@ +f(entier a, entier b) +{ +ecrire(a); +ecrire(b); +} + +main() +{ +f(1, 456); +} diff --git a/test/input/appel-param3.l b/test/input/appel-param3.l new file mode 100644 index 0000000000000000000000000000000000000000..02cbc4c8e3d17319645602ac1535739435e5b3f3 --- /dev/null +++ b/test/input/appel-param3.l @@ -0,0 +1,13 @@ +f(entier a, entier b, entier c, entier d, entier e) +{ +ecrire(a); +ecrire(b); +ecrire(c); +ecrire(d); +ecrire(e); +} + +main() +{ +f(1, 2, 3, 4, 5); +} diff --git a/test/input/appel-retour1.l b/test/input/appel-retour1.l new file mode 100644 index 0000000000000000000000000000000000000000..262eaa7c62b896d06801de75a38691577bd87d70 --- /dev/null +++ b/test/input/appel-retour1.l @@ -0,0 +1,9 @@ +entier f(entier a) +{ +retour(a); +} + +main() +{ +ecrire(f(3712)); +} diff --git a/test/input/appel1.l b/test/input/appel1.l new file mode 100644 index 0000000000000000000000000000000000000000..50282cb9ea5b0f9f2fa4e3f8738087d4b7c2070b --- /dev/null +++ b/test/input/appel1.l @@ -0,0 +1,9 @@ +f() +{ +ecrire(1); +} + +main() +{ +f(); +} diff --git a/test/input/appel2.l b/test/input/appel2.l new file mode 100644 index 0000000000000000000000000000000000000000..a96f3aa8de328c5b9efe4fb605c6d625f3cd822e --- /dev/null +++ b/test/input/appel2.l @@ -0,0 +1,15 @@ +g() +{ +ecrire(2); +} + +f() +{ +ecrire(1); +g(); +} + +main() +{ +f(); +} diff --git a/test/input/appel3.l b/test/input/appel3.l new file mode 100644 index 0000000000000000000000000000000000000000..a0a511b15da5558ccded81aec6604bdef41e7fee --- /dev/null +++ b/test/input/appel3.l @@ -0,0 +1,15 @@ +g() +{ +ecrire(2); +} + +f() +{ +ecrire(1); +} + +main() +{ +f(); +g(); +} diff --git a/test/input/clean b/test/input/clean new file mode 100755 index 0000000000000000000000000000000000000000..9f8b584eb15bea71df6fab7556cca284af4c8cdb --- /dev/null +++ b/test/input/clean @@ -0,0 +1,14 @@ +rm *.c3a +rm *.c3aout +rm *.exe +rm *.fg +rm *.fgs +rm *.ig +rm *.nasm +rm *.o +rm *.out +rm *.pre-nasm +rm *.sa +rm *.saout +rm *.sc +rm *.ts diff --git a/test/input/div1.l b/test/input/div1.l new file mode 100644 index 0000000000000000000000000000000000000000..1883db14c7a48b8cbd2e83f08bf0f56f3fe4dff9 --- /dev/null +++ b/test/input/div1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(4 / 2); +} diff --git a/test/input/div2.l b/test/input/div2.l new file mode 100644 index 0000000000000000000000000000000000000000..bbf4a3a42bc930fff183929546231ab08dcaa94f --- /dev/null +++ b/test/input/div2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(0 / 712); +} diff --git a/test/input/div3.l b/test/input/div3.l new file mode 100644 index 0000000000000000000000000000000000000000..3ba8af5d896a381c6007b7e4c18d9a9d09f83b1a --- /dev/null +++ b/test/input/div3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(4 / 2 / 2); +} diff --git a/test/input/div4.l b/test/input/div4.l new file mode 100644 index 0000000000000000000000000000000000000000..6d7ad34caae82faf396bfd69e0a00441960e6a2e --- /dev/null +++ b/test/input/div4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 / 3); +} diff --git a/test/input/ecrire1.l b/test/input/ecrire1.l new file mode 100644 index 0000000000000000000000000000000000000000..fb46c6305b643f5995cc1c1cb851af461d34de3f --- /dev/null +++ b/test/input/ecrire1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(3456); +} diff --git a/test/input/ecrire2.l b/test/input/ecrire2.l new file mode 100644 index 0000000000000000000000000000000000000000..04a17b45b509056170ac3664a8e3a335b4a2b549 --- /dev/null +++ b/test/input/ecrire2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(0); +} diff --git a/test/input/egal1.l b/test/input/egal1.l new file mode 100644 index 0000000000000000000000000000000000000000..db5eb0dee0c1e9f1ba4cf4156d5e2e64f4a20da6 --- /dev/null +++ b/test/input/egal1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(123 = 123); +} diff --git a/test/input/egal2.l b/test/input/egal2.l new file mode 100644 index 0000000000000000000000000000000000000000..c6df09c5b82d6e2ab79f25d1c2593ba7413a7be4 --- /dev/null +++ b/test/input/egal2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(412 = 34); +} diff --git a/test/input/egal3.l b/test/input/egal3.l new file mode 100644 index 0000000000000000000000000000000000000000..af9619535c4c0f005533127b010481f95afe771c --- /dev/null +++ b/test/input/egal3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 = 2 = vrai); +} diff --git a/test/input/fibo.l b/test/input/fibo.l new file mode 100644 index 0000000000000000000000000000000000000000..f67922d1d7a91db785e6f240983a44174d93b51f --- /dev/null +++ b/test/input/fibo.l @@ -0,0 +1,14 @@ +entier fibo( entier n ) +{ + si n < 2 alors { + retour 1; + } + sinon { + retour fibo( n - 1 ) + fibo( n - 2 ); + } +} + +main() +{ + ecrire( fibo( 9 ) ); +} diff --git a/test/input/inf1.l b/test/input/inf1.l new file mode 100644 index 0000000000000000000000000000000000000000..57528bdd1e25e511e1d407cac927fcadd1883c1e --- /dev/null +++ b/test/input/inf1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(3 < 3); +} diff --git a/test/input/inf2.l b/test/input/inf2.l new file mode 100644 index 0000000000000000000000000000000000000000..23255bc15203d4511ff91e0e991ff4f5d6a2ef79 --- /dev/null +++ b/test/input/inf2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(4 < 1); +} diff --git a/test/input/inf3.l b/test/input/inf3.l new file mode 100644 index 0000000000000000000000000000000000000000..dbb6666c0fcaae08017df3bbff29024f3f294ad5 --- /dev/null +++ b/test/input/inf3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(312 < 475); +} diff --git a/test/input/mult1.l b/test/input/mult1.l new file mode 100644 index 0000000000000000000000000000000000000000..1d0e8ff621b28023d4bd4ffd0ac92fbf63d12455 --- /dev/null +++ b/test/input/mult1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 * 3); +} diff --git a/test/input/mult2.l b/test/input/mult2.l new file mode 100644 index 0000000000000000000000000000000000000000..06428e506955a94984078e117342b9daa03d29aa --- /dev/null +++ b/test/input/mult2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(0 * 321); +} diff --git a/test/input/mult3.l b/test/input/mult3.l new file mode 100644 index 0000000000000000000000000000000000000000..6f25bfea008b424fd1fd4199eaf4d0a09889596b --- /dev/null +++ b/test/input/mult3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(3 * 3 * 2); +} diff --git a/test/input/nettoie.sh b/test/input/nettoie.sh new file mode 100644 index 0000000000000000000000000000000000000000..e997393a9282fa28b992ded4d4943d66e5378c2b --- /dev/null +++ b/test/input/nettoie.sh @@ -0,0 +1,16 @@ +rm *.c3a +rm *.c3aout +rm *.exe +rm *.exeout +rm *.fg +rm *.fgs +rm *.ig +rm *.nasm +rm *.nasmout +rm *.o +rm *.pre-nasm +rm *.pre-nasmout +rm *.sa +rm *.saout +rm *.sc +rm *.ts diff --git a/test/input/not1.l b/test/input/not1.l new file mode 100644 index 0000000000000000000000000000000000000000..6508335f9b4a97149d484c5cd2fe3d14c601c0b7 --- /dev/null +++ b/test/input/not1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(! vrai); +} diff --git a/test/input/not2.l b/test/input/not2.l new file mode 100644 index 0000000000000000000000000000000000000000..fee01552a8624a360e162f06c033b11275e572e8 --- /dev/null +++ b/test/input/not2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(! faux); +} diff --git a/test/input/not3.l b/test/input/not3.l new file mode 100644 index 0000000000000000000000000000000000000000..e26acb5da1418f022d4984990c5e0bd02d6c9da0 --- /dev/null +++ b/test/input/not3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(! ! faux); +} diff --git a/test/input/or1.l b/test/input/or1.l new file mode 100644 index 0000000000000000000000000000000000000000..de6482ad6e2f2a7cea47f2e91723b0adbf14f65c --- /dev/null +++ b/test/input/or1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai | vrai); +} diff --git a/test/input/or2.l b/test/input/or2.l new file mode 100644 index 0000000000000000000000000000000000000000..5c16db11ba7dd330a4afa8df1d9e8d1196defa17 --- /dev/null +++ b/test/input/or2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai | faux); +} diff --git a/test/input/or3.l b/test/input/or3.l new file mode 100644 index 0000000000000000000000000000000000000000..990b4aa6037576cad8fc371d6678fe9fb5d0a377 --- /dev/null +++ b/test/input/or3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(faux | vrai); +} diff --git a/test/input/or4.l b/test/input/or4.l new file mode 100644 index 0000000000000000000000000000000000000000..96e588b628266830e81c917594c41a7230587882 --- /dev/null +++ b/test/input/or4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(faux | faux); +} diff --git a/test/input/or5.l b/test/input/or5.l new file mode 100644 index 0000000000000000000000000000000000000000..be6b474b28f6ad7569125e178d97ab1b1d75254c --- /dev/null +++ b/test/input/or5.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(faux | vrai | faux); +} diff --git a/test/input/parenth1.l b/test/input/parenth1.l new file mode 100644 index 0000000000000000000000000000000000000000..358d5254faff63203e30624944fde93eefccde66 --- /dev/null +++ b/test/input/parenth1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire((1)); +} diff --git a/test/input/parenth2.l b/test/input/parenth2.l new file mode 100644 index 0000000000000000000000000000000000000000..fd2f9979803761e97e6e99caa482615c375559eb --- /dev/null +++ b/test/input/parenth2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(((2))); +} diff --git a/test/input/prio34-1.l b/test/input/prio34-1.l new file mode 100644 index 0000000000000000000000000000000000000000..3980bbf8afab5f07d2d0d1f123f1bb85bafadbe3 --- /dev/null +++ b/test/input/prio34-1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 + 3 * 4); +} diff --git a/test/input/prio34-2.l b/test/input/prio34-2.l new file mode 100644 index 0000000000000000000000000000000000000000..4ff044729bc9287225e3f905a50c4e0abfb37db6 --- /dev/null +++ b/test/input/prio34-2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 * 3 - 4); +} diff --git a/test/input/prio34-3.l b/test/input/prio34-3.l new file mode 100644 index 0000000000000000000000000000000000000000..d6c28383e98f616553c0944e167f36586d72c58d --- /dev/null +++ b/test/input/prio34-3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(6 / 3 - 72); +} diff --git a/test/input/prio34-4.l b/test/input/prio34-4.l new file mode 100644 index 0000000000000000000000000000000000000000..943c3979a5c4dd122f4d9b643b9a18928db56148 --- /dev/null +++ b/test/input/prio34-4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(6 + 20 / 10); +} diff --git a/test/input/prio45-1.l b/test/input/prio45-1.l new file mode 100644 index 0000000000000000000000000000000000000000..126e9fb0eef9e1c071f6349a91d9c708af648349 --- /dev/null +++ b/test/input/prio45-1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 = 0 + 1); +} diff --git a/test/input/prio45-2.l b/test/input/prio45-2.l new file mode 100644 index 0000000000000000000000000000000000000000..66fe6fd16fb1a473ffd7973d83429141de85c41b --- /dev/null +++ b/test/input/prio45-2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 + 234 = 1); +} diff --git a/test/input/prio45-3.l b/test/input/prio45-3.l new file mode 100644 index 0000000000000000000000000000000000000000..5adb3a75e291a172cf957133fdf18362a3e4ca29 --- /dev/null +++ b/test/input/prio45-3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(12 < 11 + 100); +} diff --git a/test/input/prio45-4.l b/test/input/prio45-4.l new file mode 100644 index 0000000000000000000000000000000000000000..4e5398f44d6fcb60c48a58467536a16fbacec591 --- /dev/null +++ b/test/input/prio45-4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(21 - 21 < 1); +} diff --git a/test/input/prio56-1.l b/test/input/prio56-1.l new file mode 100644 index 0000000000000000000000000000000000000000..62a43542048756e4f64e35953998f7034076709f --- /dev/null +++ b/test/input/prio56-1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 = 2 & vrai); +} diff --git a/test/input/prio56-2.l b/test/input/prio56-2.l new file mode 100644 index 0000000000000000000000000000000000000000..83f2ec7b003eff6a6be6592f1fdc88285de2d832 --- /dev/null +++ b/test/input/prio56-2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai | faux = vrai); +} diff --git a/test/input/prio67-1.l b/test/input/prio67-1.l new file mode 100644 index 0000000000000000000000000000000000000000..6ef5a73c8a48ba9b1c025a43d66162f78645357e --- /dev/null +++ b/test/input/prio67-1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(faux & vrai | vrai); +} diff --git a/test/input/prio67-2.l b/test/input/prio67-2.l new file mode 100644 index 0000000000000000000000000000000000000000..d35a1a0bf95ffefee72849531255791ef326e024 --- /dev/null +++ b/test/input/prio67-2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai | vrai & faux); +} diff --git a/test/input/rec1.l b/test/input/rec1.l new file mode 100644 index 0000000000000000000000000000000000000000..aad2b968a278e933899e6b6e54736e185343f44d --- /dev/null +++ b/test/input/rec1.l @@ -0,0 +1,14 @@ +entier f(entier a) +{ +si (a = 1) alors { +retour(1); +} +sinon{ +retour(1 + f(a-1)); +} +} + +main() +{ +ecrire(f(100)); +} diff --git a/test/input/si1.l b/test/input/si1.l new file mode 100644 index 0000000000000000000000000000000000000000..e722414197395110630a5f1a8f900c0d0a89bfd9 --- /dev/null +++ b/test/input/si1.l @@ -0,0 +1,6 @@ +main() +{ +si (vrai) alors { +ecrire(vrai); +} +} diff --git a/test/input/si2.l b/test/input/si2.l new file mode 100644 index 0000000000000000000000000000000000000000..e607615f0d31bbc7132b6cb85261cd683a5ea7df --- /dev/null +++ b/test/input/si2.l @@ -0,0 +1,9 @@ +main() +{ +si (faux) alors { +ecrire(1); +} +sinon{ +ecrire(0); +} +} diff --git a/test/input/si3.l b/test/input/si3.l new file mode 100644 index 0000000000000000000000000000000000000000..1872b14f0e0d43036aaaddb3f3c6e60fef197704 --- /dev/null +++ b/test/input/si3.l @@ -0,0 +1,10 @@ +main() +{ +si (vrai) alors { +ecrire(vrai); +} +sinon{ +ecrire(faux); +} +ecrire(vrai); +} diff --git a/test/input/si4.l b/test/input/si4.l new file mode 100644 index 0000000000000000000000000000000000000000..5fe6f1b7a630ba6638da3a6925460ecd8112acc1 --- /dev/null +++ b/test/input/si4.l @@ -0,0 +1,10 @@ +main() +{ +si (faux) alors { +ecrire(vrai); +} +sinon{ +ecrire(faux); +} +ecrire(vrai); +} diff --git a/test/input/si5.l b/test/input/si5.l new file mode 100644 index 0000000000000000000000000000000000000000..d3c57595713f40267791ddb92485f79a0e497597 --- /dev/null +++ b/test/input/si5.l @@ -0,0 +1,13 @@ +main() +{ + si (vrai) alors + { + ecrire(vrai); + si (vrai) alors + { + ecrire(vrai); + } + } + ecrire(vrai); +} + diff --git a/test/input/sub1.l b/test/input/sub1.l new file mode 100644 index 0000000000000000000000000000000000000000..32394ae9aa2f966245b8949731e6ac949e870fbc --- /dev/null +++ b/test/input/sub1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(10 - 5); +} diff --git a/test/input/sub2.l b/test/input/sub2.l new file mode 100644 index 0000000000000000000000000000000000000000..6733990e9d10808ee504f0e581faa0c78225f2ee --- /dev/null +++ b/test/input/sub2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(7 - 20); +} diff --git a/test/input/sub3.l b/test/input/sub3.l new file mode 100644 index 0000000000000000000000000000000000000000..e37d95503f418011c5ba69c9f9172645af3761d2 --- /dev/null +++ b/test/input/sub3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(2 - 1 - 1); +} diff --git a/test/input/tab1.l b/test/input/tab1.l new file mode 100644 index 0000000000000000000000000000000000000000..ebaf73fec0d63e6b5bf185890e2fc2a5b910138a --- /dev/null +++ b/test/input/tab1.l @@ -0,0 +1,10 @@ +entier tab[3] +main() +{ +tab[0] = 0; +tab[1] = 1; +tab[2] = 2; +ecrire(tab[0]); +ecrire(tab[1]); +ecrire(tab[2]); +} diff --git a/test/input/tab2.l b/test/input/tab2.l new file mode 100644 index 0000000000000000000000000000000000000000..dcb20bda39a00a965361444100e9e0fef2b5de42 --- /dev/null +++ b/test/input/tab2.l @@ -0,0 +1,12 @@ +entier tab[5] +main() +entier base +{ +base = 2; +tab[base + 0] = 34; +tab[base + 1] = 74; +tab[base + 2] = 16; +ecrire(tab[2]); +ecrire(tab[3]); +ecrire(tab[4]); +} diff --git a/test/input/tab3.l b/test/input/tab3.l new file mode 100644 index 0000000000000000000000000000000000000000..aecacad7f8b601e4adecd6b0c2762bc021e9a39c --- /dev/null +++ b/test/input/tab3.l @@ -0,0 +1,15 @@ +entier tab[5] +main() +entier base, entier offset +{ +base = 2; +offset = 0; +tab[base + offset] = 34; +offset = 1; +tab[base + offset] = 74; +offset = 2; +tab[base + offset] = 16; +ecrire(tab[2]); +ecrire(tab[3]); +ecrire(tab[4]); +} diff --git a/test/input/tab4.l b/test/input/tab4.l new file mode 100644 index 0000000000000000000000000000000000000000..1a41cba1517cc02fb8c845e6dd7b20616f336e50 --- /dev/null +++ b/test/input/tab4.l @@ -0,0 +1,10 @@ +entier tab[3] +main() +{ +tab[0] = 1; +tab[tab[0]] = 12; +tab[tab[0]+1] = 13; +ecrire(tab[0]); +ecrire(tab[1]); +ecrire(tab[2]); +} diff --git a/test/input/tantque1.l b/test/input/tantque1.l new file mode 100644 index 0000000000000000000000000000000000000000..4af77aa7fcdfe268f879a39103a0fccf788458a7 --- /dev/null +++ b/test/input/tantque1.l @@ -0,0 +1,10 @@ +main() +entier a +{ +a = 10; +tantque (0 < a) faire { +ecrire(a); +a = a - 1; +} +ecrire(0); +} diff --git a/test/input/tantque2.l b/test/input/tantque2.l new file mode 100644 index 0000000000000000000000000000000000000000..4b1c59c16288e4211167a7e8a357b2c5ca256a81 --- /dev/null +++ b/test/input/tantque2.l @@ -0,0 +1,14 @@ +main() + entier a, entier b + { + a = 0; + tantque (a < 4) faire { + b = 0; + tantque (b < 4) faire { + ecrire(a); + ecrire(b); + b = b + 1; + } + a = a + 1; + } +} diff --git a/test/input/tri.l b/test/input/tri.l new file mode 100644 index 0000000000000000000000000000000000000000..ea46356e42c22269996d59b5092f98f555c68661 --- /dev/null +++ b/test/input/tri.l @@ -0,0 +1,57 @@ +entier tab[ 10 ] + +initialiser() +{ + tab[0] = 8; tab[1] = 6; tab[2] = 9; + tab[3] = 9; tab[4] = 4; tab[5] = 2; + tab[6] = 3; tab[7] = 1; tab[8] = 4; + tab[9] = 5; +} + +afficher( entier n ) +entier i +{ + i = 0; + tantque i < n faire { + ecrire( tab[ i ] ); + i = i + 1; + } + ecrire( 0 ); # marqueur fin de tableau +} + +echanger( entier i, entier j ) +entier temp +{ + temp = tab[ j ]; + tab[ j ] = tab[ i ]; + tab[ i ] = temp; +} + +trier( entier n ) +entier echange, entier j, entier m +{ + m = n; + echange = 1; + tantque echange = 1 faire + { + echange = 0; + j = 0; + tantque j < m - 1 faire + { + si tab[ j + 1 ] < tab[ j ] alors { + echanger( j, j + 1 ); + echange = 1; + } + j = j + 1; + } + m = m - 1; + } +} + +main() +{ + initialiser(); + afficher( 10 ); + trier( 10 ); + afficher( 10 ); +} diff --git a/test/input/varglob1.l b/test/input/varglob1.l new file mode 100644 index 0000000000000000000000000000000000000000..c8dc7affb0bdf7fc533136e47b61a4e79e0839de --- /dev/null +++ b/test/input/varglob1.l @@ -0,0 +1,6 @@ +entier variable +main() +{ +variable = 6834; +ecrire(variable); +} diff --git a/test/input/varglob2.l b/test/input/varglob2.l new file mode 100644 index 0000000000000000000000000000000000000000..30f2aad361a62bdd23ca5eb8b408b741312ced59 --- /dev/null +++ b/test/input/varglob2.l @@ -0,0 +1,6 @@ +entier variable +main() +{ +variable = 10; +ecrire(variable + 50 ); +} diff --git a/test/input/varglob3.l b/test/input/varglob3.l new file mode 100644 index 0000000000000000000000000000000000000000..8211c240806500f7e886e1cfcf07180d8c9e0313 --- /dev/null +++ b/test/input/varglob3.l @@ -0,0 +1,8 @@ +entier var1, entier var2 +main() +{ +var1 = 10; +var2 = 34; +ecrire(var1); +ecrire(var2); +} diff --git a/test/input/varglob4.l b/test/input/varglob4.l new file mode 100644 index 0000000000000000000000000000000000000000..fa170c9b3499af2b25be20570a7a736dcd4d37cb --- /dev/null +++ b/test/input/varglob4.l @@ -0,0 +1,7 @@ +entier var1, entier var2 +main() +{ +var1 = 10; +var2 = 34; +ecrire(var1 + var2); +} diff --git a/test/input/varloc1.l b/test/input/varloc1.l new file mode 100644 index 0000000000000000000000000000000000000000..babef23bbb8c6d64e8dfdacb0664752a5081e6df --- /dev/null +++ b/test/input/varloc1.l @@ -0,0 +1,6 @@ +main() +entier variable +{ +variable = 6834; +ecrire(variable); +} diff --git a/test/input/varloc2.l b/test/input/varloc2.l new file mode 100644 index 0000000000000000000000000000000000000000..7899e0897ad8243c54fb5950ddb8d178edabb1a3 --- /dev/null +++ b/test/input/varloc2.l @@ -0,0 +1,6 @@ +main() +entier variable +{ +variable = 10; +ecrire(variable + 50 ); +} diff --git a/test/input/varloc3.l b/test/input/varloc3.l new file mode 100644 index 0000000000000000000000000000000000000000..34125a021421208cd13b9f2fe2ddda901146fac4 --- /dev/null +++ b/test/input/varloc3.l @@ -0,0 +1,8 @@ +main() +entier var1, entier var2 +{ +var1 = 10; +var2 = 30; +ecrire(var1); +ecrire(var2); +} diff --git a/test/input/varloc4.l b/test/input/varloc4.l new file mode 100644 index 0000000000000000000000000000000000000000..5b315ab9fee69b56301ff7d5e7b31f83174fb5f6 --- /dev/null +++ b/test/input/varloc4.l @@ -0,0 +1,7 @@ +main() +entier var1, entier var2 +{ +var1 = 10; +var2 = 30; +ecrire(var1 + var2); +} diff --git a/test/input/varloc5.l b/test/input/varloc5.l new file mode 100644 index 0000000000000000000000000000000000000000..d595344d09ef079d2ca2e85b5b58d6b82a0fae9b --- /dev/null +++ b/test/input/varloc5.l @@ -0,0 +1,15 @@ +entier var1 + +f() +entier var1 +{ +var1 = 10; +ecrire(var1); +} + +main() +{ +var1 = 20; +f(); +ecrire(var1); +} diff --git a/test/input_err_ts/double_dec1.l b/test/input_err_ts/double_dec1.l new file mode 100644 index 0000000000000000000000000000000000000000..5f55b854b2ff493f5a31f3cdebb21898b8cfe994 --- /dev/null +++ b/test/input_err_ts/double_dec1.l @@ -0,0 +1,4 @@ +entier a, bool a +main(){ + +} diff --git a/test/input_err_ts/double_dec2.l b/test/input_err_ts/double_dec2.l new file mode 100644 index 0000000000000000000000000000000000000000..39291334a850f7c729dc042a4298b970c15ac251 --- /dev/null +++ b/test/input_err_ts/double_dec2.l @@ -0,0 +1,4 @@ +entier a, bool a[10] +main(){ + +} diff --git a/test/input_err_ts/double_dec3.l b/test/input_err_ts/double_dec3.l new file mode 100644 index 0000000000000000000000000000000000000000..bb9b7e37c215ab4b7ec29370357ef241935c10f6 --- /dev/null +++ b/test/input_err_ts/double_dec3.l @@ -0,0 +1,7 @@ +f(entier a) +entier a +{ +} +main(){ + +} diff --git a/test/input_err_ts/double_dec4.l b/test/input_err_ts/double_dec4.l new file mode 100644 index 0000000000000000000000000000000000000000..36d911cc09a351eafa034c5ca862ccfd12eb41f6 --- /dev/null +++ b/test/input_err_ts/double_dec4.l @@ -0,0 +1,10 @@ +f(entier a) +{ +} + +f(entier b) +{ +} +main(){ + +} diff --git a/test/input_err_ts/fct_inconnue1.l b/test/input_err_ts/fct_inconnue1.l new file mode 100644 index 0000000000000000000000000000000000000000..f1a39929695525f8989fa3681ec364d918642f84 --- /dev/null +++ b/test/input_err_ts/fct_inconnue1.l @@ -0,0 +1,3 @@ +main(){ +f(2); +} diff --git a/test/input_err_ts/mauvais_nb_arg1.l b/test/input_err_ts/mauvais_nb_arg1.l new file mode 100644 index 0000000000000000000000000000000000000000..72819105f7a0c9f797d70611e6dc1d3794d754a8 --- /dev/null +++ b/test/input_err_ts/mauvais_nb_arg1.l @@ -0,0 +1,7 @@ +entier f(entier a, entier b) +{ +} + +main(){ +f(2); +} diff --git a/test/input_err_ts/var_inconnue1.l b/test/input_err_ts/var_inconnue1.l new file mode 100644 index 0000000000000000000000000000000000000000..5257ff81e6bb1acc84edc60b14a6756e260a94da --- /dev/null +++ b/test/input_err_ts/var_inconnue1.l @@ -0,0 +1,3 @@ +main(){ +a = 1; +} diff --git a/test/input_err_type/add1.l b/test/input_err_type/add1.l new file mode 100644 index 0000000000000000000000000000000000000000..a030276253b6d71647515145a1631794aa094f4a --- /dev/null +++ b/test/input_err_type/add1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 + vrai); +} diff --git a/test/input_err_type/add2.l b/test/input_err_type/add2.l new file mode 100644 index 0000000000000000000000000000000000000000..b96ee726d846d4eb26a6fe85aad07702341eba53 --- /dev/null +++ b/test/input_err_type/add2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai + 1); +} diff --git a/test/input_err_type/add3.l b/test/input_err_type/add3.l new file mode 100644 index 0000000000000000000000000000000000000000..93bcee1a35f94b263734a8676eabb5e7e819382f --- /dev/null +++ b/test/input_err_type/add3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai + faux); +} diff --git a/test/input_err_type/add4.l b/test/input_err_type/add4.l new file mode 100644 index 0000000000000000000000000000000000000000..e71571e72e7f010b8d605c4f7355bab7a2c42a6b --- /dev/null +++ b/test/input_err_type/add4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(!(1 + 1)); +} diff --git a/test/input_err_type/affect1.l b/test/input_err_type/affect1.l new file mode 100644 index 0000000000000000000000000000000000000000..0a0a6928a3ed89d66e5bf28b8951aee76d150b06 --- /dev/null +++ b/test/input_err_type/affect1.l @@ -0,0 +1,5 @@ +entier a +main() +{ +a = vrai; +} diff --git a/test/input_err_type/affect2.l b/test/input_err_type/affect2.l new file mode 100644 index 0000000000000000000000000000000000000000..b9b85863d01451559074e751877d36cfdf5f172a --- /dev/null +++ b/test/input_err_type/affect2.l @@ -0,0 +1,5 @@ +bool a +main() +{ +a = 1; +} diff --git a/test/input_err_type/affect3.l b/test/input_err_type/affect3.l new file mode 100644 index 0000000000000000000000000000000000000000..4ce9a7bd7e4c0934e2304679cf465fe1b3b42739 --- /dev/null +++ b/test/input_err_type/affect3.l @@ -0,0 +1,5 @@ +entier t[1] +main() +{ +t[1] = vrai; +} diff --git a/test/input_err_type/affect4.l b/test/input_err_type/affect4.l new file mode 100644 index 0000000000000000000000000000000000000000..d2791d881a66b60c122851577591373091998a0b --- /dev/null +++ b/test/input_err_type/affect4.l @@ -0,0 +1,5 @@ +bool t[1] +main() +{ +t[1] = 1; +} diff --git a/test/input_err_type/and1.l b/test/input_err_type/and1.l new file mode 100644 index 0000000000000000000000000000000000000000..3dccb993e21cc8114cd7a710b071483c7f3c5cf6 --- /dev/null +++ b/test/input_err_type/and1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai & 1); +} diff --git a/test/input_err_type/and2.l b/test/input_err_type/and2.l new file mode 100644 index 0000000000000000000000000000000000000000..b42f40a1ba6b52bc0d827bd244bee8df407b87e9 --- /dev/null +++ b/test/input_err_type/and2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 & vrai); +} diff --git a/test/input_err_type/and3.l b/test/input_err_type/and3.l new file mode 100644 index 0000000000000000000000000000000000000000..3444bc0d755f2f2cda380a1daaef608a31c9da10 --- /dev/null +++ b/test/input_err_type/and3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 & 1); +} diff --git a/test/input_err_type/and4.l b/test/input_err_type/and4.l new file mode 100644 index 0000000000000000000000000000000000000000..21f7fc286c9e61bdbd73e2f782d90d4343201fde --- /dev/null +++ b/test/input_err_type/and4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire((vrai & vrai) + 1); +} diff --git a/test/input_err_type/appel1.l b/test/input_err_type/appel1.l new file mode 100644 index 0000000000000000000000000000000000000000..4c912228e2c453a9f6211529e420c81b699a2269 --- /dev/null +++ b/test/input_err_type/appel1.l @@ -0,0 +1,8 @@ +entier f(entier a) +{ +} + +main() +{ +f(vrai); +} diff --git a/test/input_err_type/appel2.l b/test/input_err_type/appel2.l new file mode 100644 index 0000000000000000000000000000000000000000..196542bb04a4c3a9c51255c39b573c0cc8f64ec0 --- /dev/null +++ b/test/input_err_type/appel2.l @@ -0,0 +1,8 @@ +bool f(bool a) +{ +} + +main() +{ +f(1); +} diff --git a/test/input_err_type/appel3.l b/test/input_err_type/appel3.l new file mode 100644 index 0000000000000000000000000000000000000000..f4254ae26143dfd57a491e731cdc1a0039ddd34a --- /dev/null +++ b/test/input_err_type/appel3.l @@ -0,0 +1,8 @@ +bool f(bool a, bool b) +{ +} + +main() +{ +f(vrai, 1); +} diff --git a/test/input_err_type/appel4.l b/test/input_err_type/appel4.l new file mode 100644 index 0000000000000000000000000000000000000000..2ccd99f24fb05dcfbbc853bfbf3c86416e4bdc44 --- /dev/null +++ b/test/input_err_type/appel4.l @@ -0,0 +1,8 @@ +bool f(entier a, entier b) +{ +} + +main() +{ +f(1, faux); +} diff --git a/test/input_err_type/div1.l b/test/input_err_type/div1.l new file mode 100644 index 0000000000000000000000000000000000000000..321b3c8e99f55165afa1fe35b30a24d85734cb68 --- /dev/null +++ b/test/input_err_type/div1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 / vrai); +} diff --git a/test/input_err_type/div2.l b/test/input_err_type/div2.l new file mode 100644 index 0000000000000000000000000000000000000000..10e5ab357a1427f8aa1c7158f083c14a43477092 --- /dev/null +++ b/test/input_err_type/div2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai / 1); +} diff --git a/test/input_err_type/div3.l b/test/input_err_type/div3.l new file mode 100644 index 0000000000000000000000000000000000000000..5bc1aabaa4c6ff93ee637abb89d899c56aea3731 --- /dev/null +++ b/test/input_err_type/div3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai / faux); +} diff --git a/test/input_err_type/div4.l b/test/input_err_type/div4.l new file mode 100644 index 0000000000000000000000000000000000000000..f9b3c30363ed463a38905bcab806904e4a87586f --- /dev/null +++ b/test/input_err_type/div4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(!(1 / 1)); +} diff --git a/test/input_err_type/egal1.l b/test/input_err_type/egal1.l new file mode 100644 index 0000000000000000000000000000000000000000..bcbc76663e7966fb082165b0943ba5d22514a173 --- /dev/null +++ b/test/input_err_type/egal1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 = vrai); +} diff --git a/test/input_err_type/egal2.l b/test/input_err_type/egal2.l new file mode 100644 index 0000000000000000000000000000000000000000..e33cf97884677de82d6b098be06c440100da314e --- /dev/null +++ b/test/input_err_type/egal2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai = 1); +} diff --git a/test/input_err_type/egal3.l b/test/input_err_type/egal3.l new file mode 100644 index 0000000000000000000000000000000000000000..923e15de5b8ebeb3c7248cd505de8c00e1951002 --- /dev/null +++ b/test/input_err_type/egal3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire((1 = 1) + 1); +} diff --git a/test/input_err_type/egal3.nasm b/test/input_err_type/egal3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..9e9eac4d4bec6dc975db3f9e50212792d3d3666d --- /dev/null +++ b/test/input_err_type/egal3.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/input_err_type/inf1.l b/test/input_err_type/inf1.l new file mode 100644 index 0000000000000000000000000000000000000000..80b0a60d28d4a71b14ef9204cf28c5ad7cf5e852 --- /dev/null +++ b/test/input_err_type/inf1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 < vrai); +} diff --git a/test/input_err_type/inf2.l b/test/input_err_type/inf2.l new file mode 100644 index 0000000000000000000000000000000000000000..28ce301b45cdd6b13fcaa4a1f45786e07db1c265 --- /dev/null +++ b/test/input_err_type/inf2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai < 1); +} diff --git a/test/input_err_type/inf3.l b/test/input_err_type/inf3.l new file mode 100644 index 0000000000000000000000000000000000000000..a57d7f48f95347c873492c906d1c400bd73ecc47 --- /dev/null +++ b/test/input_err_type/inf3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai < faux); +} diff --git a/test/input_err_type/inf3.nasm b/test/input_err_type/inf3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..cd004aa7a69c577b68f58ca733bc81b864b001d1 --- /dev/null +++ b/test/input_err_type/inf3.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 1 ;JumpIfLess 1 + cmp eax, 0 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/input_err_type/inf4.l b/test/input_err_type/inf4.l new file mode 100644 index 0000000000000000000000000000000000000000..f0301e20bd9b8c4c283ee4a08b72e5fa8cee2a1c --- /dev/null +++ b/test/input_err_type/inf4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire((1 < 1) + 1); +} diff --git a/test/input_err_type/mult1.l b/test/input_err_type/mult1.l new file mode 100644 index 0000000000000000000000000000000000000000..8f4d37872c81b7d4790d19b15941cc7dda816738 --- /dev/null +++ b/test/input_err_type/mult1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 * vrai); +} diff --git a/test/input_err_type/mult2.l b/test/input_err_type/mult2.l new file mode 100644 index 0000000000000000000000000000000000000000..48f4598f03ec737de7b772c2dbbe421535aebc78 --- /dev/null +++ b/test/input_err_type/mult2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai * 1); +} diff --git a/test/input_err_type/mult3.l b/test/input_err_type/mult3.l new file mode 100644 index 0000000000000000000000000000000000000000..b836a332c9fbcc09aa43b17cf015345840e6e4f6 --- /dev/null +++ b/test/input_err_type/mult3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai * faux); +} diff --git a/test/input_err_type/mult4.l b/test/input_err_type/mult4.l new file mode 100644 index 0000000000000000000000000000000000000000..07a49bb4609b754c4c42b455cf3decb3208f3a59 --- /dev/null +++ b/test/input_err_type/mult4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(!(1 * 1)); +} diff --git a/test/input_err_type/not1.l b/test/input_err_type/not1.l new file mode 100644 index 0000000000000000000000000000000000000000..12d8b4265d7d2cc24d9ccd81c72945be3713ddf5 --- /dev/null +++ b/test/input_err_type/not1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(! 1); +} diff --git a/test/input_err_type/or1.l b/test/input_err_type/or1.l new file mode 100644 index 0000000000000000000000000000000000000000..4c9d12991cfd796ffb9446af0fe045753e2f9327 --- /dev/null +++ b/test/input_err_type/or1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai | 1); +} diff --git a/test/input_err_type/or2.l b/test/input_err_type/or2.l new file mode 100644 index 0000000000000000000000000000000000000000..f4324ff7ab7477d94593a438630389e3d7260be8 --- /dev/null +++ b/test/input_err_type/or2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 | faux); +} diff --git a/test/input_err_type/or3.l b/test/input_err_type/or3.l new file mode 100644 index 0000000000000000000000000000000000000000..7bfcff9abcb2c11822c8fd790f145051b18647e7 --- /dev/null +++ b/test/input_err_type/or3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire((vrai | vrai) + 1); +} diff --git a/test/input_err_type/or4.l b/test/input_err_type/or4.l new file mode 100644 index 0000000000000000000000000000000000000000..7bfcff9abcb2c11822c8fd790f145051b18647e7 --- /dev/null +++ b/test/input_err_type/or4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire((vrai | vrai) + 1); +} diff --git a/test/input_err_type/retour1.l b/test/input_err_type/retour1.l new file mode 100644 index 0000000000000000000000000000000000000000..dd2a19bcadab893fcd3968685d1f8bdc8ddd122c --- /dev/null +++ b/test/input_err_type/retour1.l @@ -0,0 +1,9 @@ +bool f(entier a) +{ +retour(a); +} + +main() +{ +f(3712); +} diff --git a/test/input_err_type/retour2.l b/test/input_err_type/retour2.l new file mode 100644 index 0000000000000000000000000000000000000000..beedbe70a9d1a68aabdd785a494cc704a7d1b54e --- /dev/null +++ b/test/input_err_type/retour2.l @@ -0,0 +1,9 @@ +entier f(bool a) +{ +retour(a); +} + +main() +{ +f(vrai); +} diff --git a/test/input_err_type/retour3.l b/test/input_err_type/retour3.l new file mode 100644 index 0000000000000000000000000000000000000000..76ced6479218a5eeff6298babb99ac8191fb5d91 --- /dev/null +++ b/test/input_err_type/retour3.l @@ -0,0 +1,9 @@ +f(entier a) +{ +retour(a); +} + +main() +{ +f(3712); +} diff --git a/test/input_err_type/si1.l b/test/input_err_type/si1.l new file mode 100644 index 0000000000000000000000000000000000000000..cb241484c9820d6b7c1a2c914f245685612093d9 --- /dev/null +++ b/test/input_err_type/si1.l @@ -0,0 +1,5 @@ +main() +{ +si (1) alors { +} +} diff --git a/test/input_err_type/sub1.l b/test/input_err_type/sub1.l new file mode 100644 index 0000000000000000000000000000000000000000..8b8dd5522e075da4a1a00cbe88b6f0860cacdf7a --- /dev/null +++ b/test/input_err_type/sub1.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(1 - vrai); +} diff --git a/test/input_err_type/sub2.l b/test/input_err_type/sub2.l new file mode 100644 index 0000000000000000000000000000000000000000..252c03f0ca29a350683fcdaa1b689a4ff9f58d34 --- /dev/null +++ b/test/input_err_type/sub2.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai - 1); +} diff --git a/test/input_err_type/sub3.l b/test/input_err_type/sub3.l new file mode 100644 index 0000000000000000000000000000000000000000..c36f785a07e66a94881b7476b0e2f9db36390ec6 --- /dev/null +++ b/test/input_err_type/sub3.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(vrai - vrai); +} diff --git a/test/input_err_type/sub4.l b/test/input_err_type/sub4.l new file mode 100644 index 0000000000000000000000000000000000000000..b6b7bfb9b8b8e83ce858937eb7633a9b613270e9 --- /dev/null +++ b/test/input_err_type/sub4.l @@ -0,0 +1,4 @@ +main() +{ +ecrire(!( 1 - 1)); +} diff --git a/test/input_err_type/tantque1.l b/test/input_err_type/tantque1.l new file mode 100644 index 0000000000000000000000000000000000000000..6344c62ae0341316d4240bb848f11dfc77c27bdb --- /dev/null +++ b/test/input_err_type/tantque1.l @@ -0,0 +1,5 @@ +main() +{ +tantque (1) faire { +} +} diff --git a/test/io.asm b/test/io.asm new file mode 100644 index 0000000000000000000000000000000000000000..cee4da2ae3a4746873a75a15688938b608c91b87 --- /dev/null +++ b/test/io.asm @@ -0,0 +1,205 @@ + global iprintLF +;------------------------------------------ +; void readline +; Read a line from stdin, store string after [$eax] +; WARNING: does not check for buffer overflow - insecure! +readline: + push edx ; preserve edx on stack to be restored after function + push ecx ; preserve ecx on stack to be restored after function + push ebx ; preserve ebx on stack to be restored after function + push eax ; preserve eax on stack to be restored after function + mov ecx, eax ; address where store result +continue_reading: + mov eax, 3 ; syscall is read = 3 + mov ebx, 0 ; fd is stdin = 0 + mov edx, 1 ; nb. of bytes to read + int 80h ; call interruption + cmp eax, 0 ; if no byte read, then we reached EOF, stop + je end_reading + cmp BYTE [ecx], 10 ; Found '\n', stop reading string + je end_reading + cmp BYTE [ecx], 13 ; Found '\r', stop reading string + je end_reading + inc ecx ; None of above, increment pointer and read next byte + jmp continue_reading +end_reading: + mov BYTE [ecx], 0 ; Add zero to yield null-terminated string + pop eax ; restore eax from value pushed onto stack at start + pop ebx ; restore eax from value pushed onto stack at start + pop ecx ; restore eax from value pushed onto stack at start + pop edx ; restore eax from value pushed onto stack at start + ret + +;------------------------------------------ +; void iprint(Integer number) +; Integer printing function (itoa) +iprint: + push eax ; preserve eax on the stack to be restored after function runs + push ecx ; preserve ecx on the stack to be restored after function runs + push edx ; preserve edx on the stack to be restored after function runs + push esi ; preserve esi on the stack to be restored after function runs + + cmp eax, 0 + jge positive + push eax ; preserve eax value + mov ebx, '-' + push ebx + mov eax, esp + call sprint + pop eax ; remove '-' sign + pop eax ; retrieve eax value + neg eax +positive: + mov ecx, 0 ; counter of how many bytes we need to print in the end +divideLoop: + inc ecx ; count each byte to print - number of characters + mov edx, 0 ; empty edx + mov esi, 10 ; mov 10 into esi + idiv esi ; divide eax by esi + add edx, 48 ; convert edx to it's ascii representation - edx holds the remainder after a divide instruction + push edx ; push edx (string representation of an intger) onto the stack + cmp eax, 0 ; can the integer be divided anymore? + jnz divideLoop ; jump if not zero to the label divideLoop + +printLoop: + dec ecx ; count down each byte that we put on the stack + mov eax, esp ; mov the stack pointer into eax for printing + call sprint ; call our string print function + pop eax ; remove last character from the stack to move esp forward + cmp ecx, 0 ; have we printed all bytes we pushed onto the stack? + jnz printLoop ; jump is not zero to the label printLoop + + pop esi ; restore esi from the value we pushed onto the stack at the start + pop edx ; restore edx from the value we pushed onto the stack at the start + pop ecx ; restore ecx from the value we pushed onto the stack at the start + pop eax ; restore eax from the value we pushed onto the stack at the start + ret + + +;------------------------------------------ +; void iprintLF(Integer number) +; Integer printing function with linefeed (itoa) +iprintLF: + call iprint ; call our integer printing function + + push eax ; push eax onto the stack to preserve it while we use the eax register in this function + mov eax, 0Ah ; move 0Ah into eax - 0Ah is the ascii character for a linefeed + push eax ; push the linefeed onto the stack so we can get the address + mov eax, esp ; move the address of the current stack pointer into eax for sprint + call sprint ; call our sprint function + pop eax ; remove our linefeed character from the stack + pop eax ; restore the original value of eax before our function was called + ret + + +;------------------------------------------ +; int slen(String message) +; String length calculation function +slen: + push ebx + mov ebx, eax + +nextchar: + cmp byte [eax], 0 + jz finished + inc eax + jmp nextchar + +finished: + sub eax, ebx + pop ebx + ret + + +;------------------------------------------ +; void sprint(String message) +; String printing function +sprint: + push edx + push ecx + push ebx + push eax + call slen + + mov edx, eax + pop eax + + mov ecx, eax + mov ebx, 1 + mov eax, 4 + int 80h + + pop ebx + pop ecx + pop edx + ret + + +;------------------------------------------ +; void sprintLF(String message) +; String printing with line feed function +sprintLF: + call sprint + + push eax + mov eax, 0AH + push eax + mov eax, esp + call sprint + pop eax + pop eax + ret + + +;------------------------------------------ +; void exit() +; Exit program and restore resources +quit: + mov ebx, 0 + mov eax, 1 + int 80h + ret + +;------------------------------------------ +; int atoi(Integer number) +; Ascii to integer function (atoi) +atoi: + push ebx ; preserve ebx on the stack to be restored after function runs + push ecx ; preserve ecx on the stack to be restored after function runs + push edx ; preserve edx on the stack to be restored after function runs + push esi ; preserve esi on the stack to be restored after function runs + xor ebx, ebx ; initialize forming answer + xor ecx, ecx ; initialize sign flag + mov esi, eax +atoi1: + lodsb ; scan off whitespace + cmp al, ' ' ; ignore leading blanks + je atoi1 + cmp al, '+' ; if + sign proceed + je atoi2 + cmp al, '-' ; is it - sign? + jne atoi3 ; no, test if numeric + dec ecx ; was - sign, set flag for negative result +atoi2: + lodsb ; get next character +atoi3: + cmp al,'0' ; is character valid? + jb atoi4 ; jump if not '0' to '9' + cmp al,'9' + ja atoi4 ; jump if not '0' to '9' + and eax, 000fh ; isolate lower four bits + xchg ebx, eax ; multiply answer x 10 + mov edx, 10 + mul edx + add ebx, eax ; add this digit + jmp atoi2 ; convert next digit +atoi4: + mov eax,ebx ; result into AX + jcxz atoi5 ; jump if sign flag clear + neg eax ; make result negative +atoi5: + pop esi ; restore esi from the value we pushed onto the stack at the start + pop edx ; restore edx from the value we pushed onto the stack at the start + pop ecx ; restore ecx from the value we pushed onto the stack at the start + pop ebx ; restore ebx from the value we pushed onto the stack at the start + ret diff --git a/test/nasm-ref/add1.nasm b/test/nasm-ref/add1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..bc09d48fc391ac1a47f33912e5b1fdca89447fd0 --- /dev/null +++ b/test/nasm-ref/add1.nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 3 + add eax, 10 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/add2.nasm b/test/nasm-ref/add2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..4410bcaf7e670b4fd228776e69275b62f4fabf20 --- /dev/null +++ b/test/nasm-ref/add2.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 + add eax, 4 + mov eax, eax + add eax, 8 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/affect1.nasm b/test/nasm-ref/affect1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..727926384620af32e1c1c412bcaaf20473e7a171 --- /dev/null +++ b/test/nasm-ref/affect1.nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +a : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [a], 1 ;Affect + mov eax, dword [a] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/affect2.nasm b/test/nasm-ref/affect2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..13e0f37886036af558bc95f1d33ea5637553aaa6 --- /dev/null +++ b/test/nasm-ref/affect2.nasm @@ -0,0 +1,31 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 1 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/affect3.nasm b/test/nasm-ref/affect3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..0a52b93b4fc356494011718d51bb8eec982dc4b8 --- /dev/null +++ b/test/nasm-ref/affect3.nasm @@ -0,0 +1,50 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [ebp+12], 1 ;Affect + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + push 3 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/and1.nasm b/test/nasm-ref/and1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..a4246bc7784f17ded7c1f9f015fe35280f59b242 --- /dev/null +++ b/test/nasm-ref/and1.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/and2.nasm b/test/nasm-ref/and2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..c1132c69b97f30c4e8b928a1d6fd5c73a4b2a40d --- /dev/null +++ b/test/nasm-ref/and2.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/and3.nasm b/test/nasm-ref/and3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..47d936c85fc18a3f73806dd02341a71114996fd3 --- /dev/null +++ b/test/nasm-ref/and3.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/and4.nasm b/test/nasm-ref/and4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..ae6df09fc7f24b26251ff3684237a7b963b9b609 --- /dev/null +++ b/test/nasm-ref/and4.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/and5.nasm b/test/nasm-ref/and5.nasm new file mode 100644 index 0000000000000000000000000000000000000000..fa2e52fb7fa79ebf2aad22f3b84f4e4a3f2bfa19 --- /dev/null +++ b/test/nasm-ref/and5.nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l2 ;Jump +l3 : mov eax, 0 ;Affect +l2 : cmp eax, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/appel-param1.nasm b/test/nasm-ref/appel-param1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..54428e36a95e0d6708a06f4e8fb91652116ba96a --- /dev/null +++ b/test/nasm-ref/appel-param1.nasm @@ -0,0 +1,49 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 1 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/appel-param2.nasm b/test/nasm-ref/appel-param2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..0ebec5e449f36bb52aa6d0385bb71ef1b1a71461 --- /dev/null +++ b/test/nasm-ref/appel-param2.nasm @@ -0,0 +1,52 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, dword [ebp+16] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 1 ;Param + push 456 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 8 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/appel-param3.nasm b/test/nasm-ref/appel-param3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..efa08558ce502d7f95b24c8ff197b1505a9d3ce4 --- /dev/null +++ b/test/nasm-ref/appel-param3.nasm @@ -0,0 +1,61 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, dword [ebp+28] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+24] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+20] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+16] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 1 ;Param + push 2 ;Param + push 3 ;Param + push 4 ;Param + push 5 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 20 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/appel-retour1.nasm b/test/nasm-ref/appel-retour1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..45a6fd9d41fb43dbc5ee3ca8430198c6dc565cc4 --- /dev/null +++ b/test/nasm-ref/appel-retour1.nasm @@ -0,0 +1,58 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, dword [ebp+12] ;ecriture de la valeur de retour + mov dword [ebp+8], eax ;on passe par un registre temporaire + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 3712 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/appel1.nasm b/test/nasm-ref/appel1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..67597761cad71746b4443ed76f0f5c142b1f6ef2 --- /dev/null +++ b/test/nasm-ref/appel1.nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/appel2.nasm b/test/nasm-ref/appel2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..7cc2d8f7ccf7b60245a76f8c40ec95db89c67d96 --- /dev/null +++ b/test/nasm-ref/appel2.nasm @@ -0,0 +1,66 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +g : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + sub esp, 4 ;allocation mémoire pour la valeur de retour + call g + pop eax ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/appel3.nasm b/test/nasm-ref/appel3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..2b9a9dfa8c79a867801156d3100560c73feaa5e3 --- /dev/null +++ b/test/nasm-ref/appel3.nasm @@ -0,0 +1,66 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +g : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + sub esp, 4 ;allocation mémoire pour la valeur de retour + call g + pop eax ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/div1.nasm b/test/nasm-ref/div1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..ef462e72dde0a802a77735c5da97713811226fcd --- /dev/null +++ b/test/nasm-ref/div1.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 4 ;affectation des bits de poids faible du dividende + mov ebx, 2 + idiv ebx + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov eax, eax + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/div2.nasm b/test/nasm-ref/div2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..e861d6ef4a3a630827143a20a78ee1de334aff56 --- /dev/null +++ b/test/nasm-ref/div2.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 0 ;affectation des bits de poids faible du dividende + mov ebx, 712 + idiv ebx + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov eax, eax + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/div3.nasm b/test/nasm-ref/div3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..ffabe24f2bb040d5e7124496d8128358ac4e2ba4 --- /dev/null +++ b/test/nasm-ref/div3.nasm @@ -0,0 +1,42 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 4 ;affectation des bits de poids faible du dividende + mov ebx, 2 + idiv ebx + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov ebx, eax + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, ebx ;affectation des bits de poids faible du dividende + mov ebx, 2 + idiv ebx + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov eax, eax + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/div4.nasm b/test/nasm-ref/div4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f5097bb447d94b60666ff95a5df862fe292ca1eb --- /dev/null +++ b/test/nasm-ref/div4.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 2 ;affectation des bits de poids faible du dividende + mov ebx, 3 + idiv ebx + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov eax, eax + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/ecrire1.nasm b/test/nasm-ref/ecrire1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..b54f3ee63d0e79cb2afe62fa9a1e13a241383cc3 --- /dev/null +++ b/test/nasm-ref/ecrire1.nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 3456 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/ecrire2.nasm b/test/nasm-ref/ecrire2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f1e10efec0cbbf021c4faeff5300f3baf120ddbd --- /dev/null +++ b/test/nasm-ref/ecrire2.nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/egal1.nasm b/test/nasm-ref/egal1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..2f92dc2e56260860e4d6ff6ab4c8d7bcb238d5ba --- /dev/null +++ b/test/nasm-ref/egal1.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 123 ;JumpIfEqual 1 + cmp eax, 123 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/egal2.nasm b/test/nasm-ref/egal2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..e18e7e7a25888dd4ff997c8949f599ddf428ccf0 --- /dev/null +++ b/test/nasm-ref/egal2.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 412 ;JumpIfEqual 1 + cmp eax, 34 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/egal3.nasm b/test/nasm-ref/egal3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..ad070f93ff52c508f3c513825ecc06f69df54db8 --- /dev/null +++ b/test/nasm-ref/egal3.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 2 ;JumpIfEqual 1 + cmp eax, 2 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l1 : mov eax, 1 ;Affect + cmp ebx, 1 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/fibo.nasm b/test/nasm-ref/fibo.nasm new file mode 100644 index 0000000000000000000000000000000000000000..ec408a375dfe24c1246df3e9a453499df4595844 --- /dev/null +++ b/test/nasm-ref/fibo.nasm @@ -0,0 +1,88 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +fibo : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Affect + cmp dword [ebp+12], 2 ;JumpIfLess 1 + jl l2 ;JumpIfLess 2 + mov eax, 0 ;Affect +l2 : cmp eax, 0 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov dword [ebp+8], 1 ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret + jmp l1 ;Jump +l0 : mov eax, dword [ebp+12] + sub eax, 1 + push eax ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call fibo + pop ecx ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, dword [ebp+12] + sub eax, 2 + push eax ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call fibo + pop ebx ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, ecx + add eax, ebx + mov dword [ebp+8], eax ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 9 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call fibo + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/inf1.nasm b/test/nasm-ref/inf1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..bd13a5f82949fd1fae7cbdfb39adf8c218d5d159 --- /dev/null +++ b/test/nasm-ref/inf1.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 3 ;JumpIfLess 1 + cmp eax, 3 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/inf2.nasm b/test/nasm-ref/inf2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..affb58cf92cdc64faabc4b376374c695820a476d --- /dev/null +++ b/test/nasm-ref/inf2.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 4 ;JumpIfLess 1 + cmp eax, 1 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/inf3.nasm b/test/nasm-ref/inf3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..5885172d49b57b6660a6ec3c490a6b5cff4e8cd0 --- /dev/null +++ b/test/nasm-ref/inf3.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 312 ;JumpIfLess 1 + cmp eax, 475 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/inf4.nasm b/test/nasm-ref/inf4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..013435ea8b6e1cfac6c51bcc687ffd8b954553a4 --- /dev/null +++ b/test/nasm-ref/inf4.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 3 ;JumpIfLess 1 + cmp eax, 2 ;on passe par un registre temporaire + jl l1 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l1 : mov eax, 1 ;Affect + cmp ebx, 1 ;JumpIfLess 1 + jl l0 ;JumpIfLess 2 + mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/nasm-ref/mult1.nasm b/test/nasm-ref/mult1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f76c44104b94899e0c418b997f73f88990ac6445 --- /dev/null +++ b/test/nasm-ref/mult1.nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 + imul eax, 3 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/mult2.nasm b/test/nasm-ref/mult2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..6e1901e13d18d83e23df160556fe1d16939ab775 --- /dev/null +++ b/test/nasm-ref/mult2.nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 + imul eax, 321 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/mult3.nasm b/test/nasm-ref/mult3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..63f4199dc9df139a894619b8ebd0d19191be46aa --- /dev/null +++ b/test/nasm-ref/mult3.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 3 + imul eax, 3 + mov eax, eax + imul eax, 2 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/not1.nasm b/test/nasm-ref/not1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..fa6921f39b1fcccc8718d457632f539c03b0f914 --- /dev/null +++ b/test/nasm-ref/not1.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/not2.nasm b/test/nasm-ref/not2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..7f55870901ad5f11302c4ef7311e33bbfcca9b0a --- /dev/null +++ b/test/nasm-ref/not2.nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/not3.nasm b/test/nasm-ref/not3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..a2c8f2e76de74c40656a21c5490acbb237d31e95 --- /dev/null +++ b/test/nasm-ref/not3.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l1 : mov eax, 1 ;Affect + cmp ebx, 0 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/or1.nasm b/test/nasm-ref/or1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..7573ac5834c9877b7a3c57a3f6ba9799e00f7ebf --- /dev/null +++ b/test/nasm-ref/or1.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/or2.nasm b/test/nasm-ref/or2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..49b925dc5183ba3489419a53e0555d75a79875cb --- /dev/null +++ b/test/nasm-ref/or2.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/or3.nasm b/test/nasm-ref/or3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..03655bc1f89326096ae5ed01ad02d96c3bb8f0fb --- /dev/null +++ b/test/nasm-ref/or3.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/or4.nasm b/test/nasm-ref/or4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..aab700053973ffecf9a506a1434677cf1f05f810 --- /dev/null +++ b/test/nasm-ref/or4.nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/or5.nasm b/test/nasm-ref/or5.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f5d577dc6fe141ecb82e2e76d77d3cc09d1ee479 --- /dev/null +++ b/test/nasm-ref/or5.nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l3 ;jumpIfNotEqual 2 + mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l3 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l2 ;Jump +l3 : mov eax, 1 ;Affect +l2 : cmp eax, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/parenth1.nasm b/test/nasm-ref/parenth1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..62131a5884a1b1293693324d2278bb1000744abb --- /dev/null +++ b/test/nasm-ref/parenth1.nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/parenth2.nasm b/test/nasm-ref/parenth2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..a0a06fcdf1c8caf1975a4050d389b59e45d4fd2f --- /dev/null +++ b/test/nasm-ref/parenth2.nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio23-1.nasm b/test/nasm-ref/prio23-1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..fe42a0a4facc3f2f4a3aa78a82f50c8f2d769a91 --- /dev/null +++ b/test/nasm-ref/prio23-1.nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ; + imul eax, 10 ; + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/nasm-ref/prio23-2.nasm b/test/nasm-ref/prio23-2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..3534b14cb4662d98e22441d2cf17636e70c34bf1 --- /dev/null +++ b/test/nasm-ref/prio23-2.nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 10 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, 3 ; + imul eax, ebx ; + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/nasm-ref/prio23-3.nasm b/test/nasm-ref/prio23-3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..1eaf5d10e872651eeac4e327b04dd33f44b33343 --- /dev/null +++ b/test/nasm-ref/prio23-3.nasm @@ -0,0 +1,41 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ecx, 1 ;Affect + mov ebx, 0 ;JumpIfEqual 1 + cmp ebx, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ecx, 0 ;Affect +l0 : mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, ecx ;affectation des bits de poids faible du dividende + mov ebx, 1 ; + idiv ebx ; + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov eax, eax ; + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/nasm-ref/prio23-4.nasm b/test/nasm-ref/prio23-4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..e4ffdc78d55989222056554d2309f72632f41054 --- /dev/null +++ b/test/nasm-ref/prio23-4.nasm @@ -0,0 +1,45 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ecx, 1 ;Affect + mov ebx, 1 ;JumpIfEqual 1 + cmp ebx, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ecx, 0 ;Affect +l0 : mov ebx, 1 ;Affect + mov edx, 0 ;JumpIfEqual 1 + cmp edx, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l1 : mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, ecx ;affectation des bits de poids faible du dividende + idiv ebx ; + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov eax, eax ; + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/nasm-ref/prio34-1.nasm b/test/nasm-ref/prio34-1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..cd6c5eea1bb371fc73fca215fffbc76cd7957bb6 --- /dev/null +++ b/test/nasm-ref/prio34-1.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 3 + imul ebx, 4 + mov eax, 2 + add eax, ebx + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio34-2.nasm b/test/nasm-ref/prio34-2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..702132656d75a76268080014ad572d805d6d344c --- /dev/null +++ b/test/nasm-ref/prio34-2.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 + imul eax, 3 + mov eax, eax + sub eax, 4 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio34-3.nasm b/test/nasm-ref/prio34-3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..1f40cf8885b925c20ea2e78aad5167d1a4d2fe50 --- /dev/null +++ b/test/nasm-ref/prio34-3.nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 6 ;affectation des bits de poids faible du dividende + mov ebx, 3 + idiv ebx + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov eax, eax + mov eax, eax + sub eax, 72 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio34-4.nasm b/test/nasm-ref/prio34-4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..3de8b057f5a9916b165ee207975eda202cbb54d2 --- /dev/null +++ b/test/nasm-ref/prio34-4.nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 20 ;affectation des bits de poids faible du dividende + mov ebx, 10 + idiv ebx + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov ebx, eax + mov eax, 6 + add eax, ebx + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio45-1.nasm b/test/nasm-ref/prio45-1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..16084c61994289d9b5362b3383d9ad9bf1a8bc14 --- /dev/null +++ b/test/nasm-ref/prio45-1.nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 0 + add ebx, 1 + mov ecx, 1 ;Affect + mov eax, 2 ;JumpIfEqual 1 + cmp eax, ebx ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov ecx, 0 ;Affect +l0 : mov eax, ecx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio45-2.nasm b/test/nasm-ref/prio45-2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..1df1bfcdbc9df9d11545b497a3e7159117327e81 --- /dev/null +++ b/test/nasm-ref/prio45-2.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 + add eax, 234 + mov ebx, 1 ;Affect + cmp eax, 1 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio45-3.nasm b/test/nasm-ref/prio45-3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..866931fb3d8f476c4121bac63c4dcf94902c5311 --- /dev/null +++ b/test/nasm-ref/prio45-3.nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 11 + add ebx, 100 + mov ecx, 1 ;Affect + mov eax, 12 ;JumpIfLess 1 + cmp eax, ebx ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov ecx, 0 ;Affect +l0 : mov eax, ecx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio45-4.nasm b/test/nasm-ref/prio45-4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..64778dc79a19f0dc04cc1f617abdf86c85d605f3 --- /dev/null +++ b/test/nasm-ref/prio45-4.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 21 + sub eax, 21 + mov ebx, 1 ;Affect + cmp eax, 1 ;JumpIfLess 1 + jl l0 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l0 : mov eax, ebx ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio56-1.nasm b/test/nasm-ref/prio56-1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..dad85991cd6e823748a8a3902329ead4e9d4a8c2 --- /dev/null +++ b/test/nasm-ref/prio56-1.nasm @@ -0,0 +1,43 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 2 ;on passe par un registre temporaire + je l2 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l2 : cmp ebx, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio56-2.nasm b/test/nasm-ref/prio56-2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..5b41fc44c4d5b40dcd9affdb225e9994128aec3e --- /dev/null +++ b/test/nasm-ref/prio56-2.nasm @@ -0,0 +1,43 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov ebx, 1 ;Affect + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 1 ;on passe par un registre temporaire + je l2 ;JumpIfEqual 2 + mov ebx, 0 ;Affect +l2 : mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + cmp ebx, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio67-1.nasm b/test/nasm-ref/prio67-1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..dd5f56baf134dabc4bc97e3fe33bdc04186bd56f --- /dev/null +++ b/test/nasm-ref/prio67-1.nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 1 ;Affect + jmp l2 ;Jump +l3 : mov eax, 0 ;Affect +l2 : cmp eax, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/prio67-2.nasm b/test/nasm-ref/prio67-2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..94d07a6e3fba092d35e2b26c17a07cee77b7e9fc --- /dev/null +++ b/test/nasm-ref/prio67-2.nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov ebx, 1 ;Affect + jmp l2 ;Jump +l3 : mov ebx, 0 ;Affect +l2 : mov eax, 1 ;jumpIfNotEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + cmp ebx, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov eax, 0 ;Affect + jmp l0 ;Jump +l1 : mov eax, 1 ;Affect +l0 : mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/rec1.nasm b/test/nasm-ref/rec1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..c0f7379bcc562b0a9b6b5d0129bf4a802eacdf3c --- /dev/null +++ b/test/nasm-ref/rec1.nasm @@ -0,0 +1,81 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Affect + cmp dword [ebp+12], 1 ;JumpIfEqual 1 + je l2 ;JumpIfEqual 2 + mov eax, 0 ;Affect +l2 : cmp eax, 0 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov dword [ebp+8], 1 ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret + jmp l1 ;Jump +l0 : mov eax, dword [ebp+12] + sub eax, 1 + push eax ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop ebx ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, 1 + add eax, ebx + mov dword [ebp+8], eax ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 100 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/si1.nasm b/test/nasm-ref/si1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..cc1e2372219877c535700bbdf8fbdedcd529efab --- /dev/null +++ b/test/nasm-ref/si1.nasm @@ -0,0 +1,33 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/si2.nasm b/test/nasm-ref/si2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..a79e6a022157c55621daa63c0d46bbd0d74e6611 --- /dev/null +++ b/test/nasm-ref/si2.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + jmp l1 ;Jump +l0 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/si3.nasm b/test/nasm-ref/si3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..4f10ce83ed61f3c02012539ba21eb69f65f3baa2 --- /dev/null +++ b/test/nasm-ref/si3.nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + jmp l1 ;Jump +l0 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 +l1 : mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/si4.nasm b/test/nasm-ref/si4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..4af0c4e6aeb54e4e7a17634e6acb249b76670315 --- /dev/null +++ b/test/nasm-ref/si4.nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + jmp l1 ;Jump +l0 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 +l1 : mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/si5.nasm b/test/nasm-ref/si5.nasm new file mode 100644 index 0000000000000000000000000000000000000000..06766335eec7827b2de84a64b694e940dcef3fca --- /dev/null +++ b/test/nasm-ref/si5.nasm @@ -0,0 +1,40 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + mov eax, 1 ;JumpIfEqual 1 + cmp eax, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 +l3 : mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/sub1.nasm b/test/nasm-ref/sub1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..70cc077685dc58beb25f98a5eb3e11f757f20d18 --- /dev/null +++ b/test/nasm-ref/sub1.nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 10 + sub eax, 5 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/sub2.nasm b/test/nasm-ref/sub2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f8201ed61834abfc172407e856e33025e9121b9b --- /dev/null +++ b/test/nasm-ref/sub2.nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 7 + sub eax, 20 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/sub3.nasm b/test/nasm-ref/sub3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f45bc0713e3fb59d884a7b9217c2b0dce4b30998 --- /dev/null +++ b/test/nasm-ref/sub3.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 + sub eax, 1 + mov eax, eax + sub eax, 1 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/tab1.nasm b/test/nasm-ref/tab1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..c5ab2add2074e38837bf5de00061ffdc9a3a7b3d --- /dev/null +++ b/test/nasm-ref/tab1.nasm @@ -0,0 +1,50 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 12 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 + imul eax, 4 + mov dword [tab+eax], 0 ;Affect + mov eax, 1 + imul eax, 4 + mov dword [tab+eax], 1 ;Affect + mov eax, 2 + imul eax, 4 + mov dword [tab+eax], 2 ;Affect + mov eax, 0 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 1 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 2 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/tab2.nasm b/test/nasm-ref/tab2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..11220cb89069b4aaf6859ce73b3808bd45fbe150 --- /dev/null +++ b/test/nasm-ref/tab2.nasm @@ -0,0 +1,57 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 20 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 2 ;Affect + mov eax, dword [ebp-4] + add eax, 0 + mov eax, eax + imul eax, 4 + mov dword [tab+eax], 34 ;Affect + mov eax, dword [ebp-4] + add eax, 1 + mov eax, eax + imul eax, 4 + mov dword [tab+eax], 74 ;Affect + mov eax, dword [ebp-4] + add eax, 2 + mov eax, eax + imul eax, 4 + mov dword [tab+eax], 16 ;Affect + mov eax, 2 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 3 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 4 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/tab3.nasm b/test/nasm-ref/tab3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..a992cbd9ad038e9d499ea9adaf1ff223c97288a0 --- /dev/null +++ b/test/nasm-ref/tab3.nasm @@ -0,0 +1,60 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 20 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 2 ;Affect + mov dword [ebp-8], 0 ;Affect + mov eax, dword [ebp-4] + add eax, dword [ebp-8] + mov eax, eax + imul eax, 4 + mov dword [tab+eax], 34 ;Affect + mov dword [ebp-8], 1 ;Affect + mov eax, dword [ebp-4] + add eax, dword [ebp-8] + mov eax, eax + imul eax, 4 + mov dword [tab+eax], 74 ;Affect + mov dword [ebp-8], 2 ;Affect + mov eax, dword [ebp-4] + add eax, dword [ebp-8] + mov eax, eax + imul eax, 4 + mov dword [tab+eax], 16 ;Affect + mov eax, 2 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 3 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 4 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/tab4.nasm b/test/nasm-ref/tab4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..ebef473f49f9613d10a6afe4432d44bb0d6e27e1 --- /dev/null +++ b/test/nasm-ref/tab4.nasm @@ -0,0 +1,56 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 12 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 + imul eax, 4 + mov dword [tab+eax], 1 ;Affect + mov eax, 0 + imul eax, 4 + mov eax, dword [tab+eax] + imul eax, 4 + mov dword [tab+eax], 12 ;Affect + mov eax, 0 + imul eax, 4 + mov eax, dword [tab+eax] + add eax, 1 + mov eax, eax + imul eax, 4 + mov dword [tab+eax], 13 ;Affect + mov eax, 0 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 1 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, 2 + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/tantque1.nasm b/test/nasm-ref/tantque1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..7d86ffb50a36659402a88a7f97182d4db587883b --- /dev/null +++ b/test/nasm-ref/tantque1.nasm @@ -0,0 +1,44 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect +l0 : mov ebx, 1 ;Affect + mov eax, 0 ;JumpIfLess 1 + cmp eax, dword [ebp-4] ;on passe par un registre temporaire + jl l2 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l2 : cmp ebx, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp-4] + sub eax, 1 + mov dword [ebp-4], eax ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/tantque2.nasm b/test/nasm-ref/tantque2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..760a37732b9f9519b9e5a3794650758aeeb5cf3e --- /dev/null +++ b/test/nasm-ref/tantque2.nasm @@ -0,0 +1,54 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 0 ;Affect +l0 : mov eax, 1 ;Affect + cmp dword [ebp-4], 4 ;JumpIfLess 1 + jl l2 ;JumpIfLess 2 + mov eax, 0 ;Affect +l2 : cmp eax, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov dword [ebp-8], 0 ;Affect +l3 : mov eax, 1 ;Affect + cmp dword [ebp-8], 4 ;JumpIfLess 1 + jl l5 ;JumpIfLess 2 + mov eax, 0 ;Affect +l5 : cmp eax, 0 ;JumpIfEqual 1 + je l4 ;JumpIfEqual 2 + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp-8] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp-8] + add eax, 1 + mov dword [ebp-8], eax ;Affect + jmp l3 ;Jump +l4 : mov eax, dword [ebp-4] + add eax, 1 + mov dword [ebp-4], eax ;Affect + jmp l0 ;Jump +l1 : add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/tri.nasm b/test/nasm-ref/tri.nasm new file mode 100644 index 0000000000000000000000000000000000000000..ed7a9fd07151cf5acf218d226eda0b9751a0e337 --- /dev/null +++ b/test/nasm-ref/tri.nasm @@ -0,0 +1,214 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 40 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +initialiser : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 + imul eax, 4 + mov dword [tab+eax], 8 ;Affect + mov eax, 1 + imul eax, 4 + mov dword [tab+eax], 6 ;Affect + mov eax, 2 + imul eax, 4 + mov dword [tab+eax], 9 ;Affect + mov eax, 3 + imul eax, 4 + mov dword [tab+eax], 9 ;Affect + mov eax, 4 + imul eax, 4 + mov dword [tab+eax], 4 ;Affect + mov eax, 5 + imul eax, 4 + mov dword [tab+eax], 2 ;Affect + mov eax, 6 + imul eax, 4 + mov dword [tab+eax], 3 ;Affect + mov eax, 7 + imul eax, 4 + mov dword [tab+eax], 1 ;Affect + mov eax, 8 + imul eax, 4 + mov dword [tab+eax], 4 ;Affect + mov eax, 9 + imul eax, 4 + mov dword [tab+eax], 5 ;Affect + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +afficher : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 0 ;Affect +l0 : mov ebx, 1 ;Affect + mov eax, dword [ebp-4] ;JumpIfLess 1 + cmp eax, dword [ebp+12] ;on passe par un registre temporaire + jl l2 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l2 : cmp ebx, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov eax, dword [ebp-4] + imul eax, 4 + mov eax, dword [tab+eax] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp-4] + add eax, 1 + mov dword [ebp-4], eax ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +echanger : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov eax, dword [ebp+12] + imul eax, 4 + mov eax, dword [tab+eax] ;Affect + mov dword [ebp-4], eax ;on passe par un registre temporaire + mov eax, dword [ebp+16] + imul eax, 4 + mov ebx, dword [ebp+12] + imul ebx, 4 + mov eax, dword [tab+eax] ;Affect + mov dword [tab+ebx], eax ;on passe par un registre temporaire + mov ebx, dword [ebp+16] + imul ebx, 4 + mov eax, dword [ebp-4] ;Affect + mov dword [tab+ebx], eax ;on passe par un registre temporaire + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +trier : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 12 ;allocation des variables locales + mov eax, dword [ebp+12] ;Affect + mov dword [ebp-12], eax ;on passe par un registre temporaire + mov dword [ebp-4], 1 ;Affect +l3 : mov eax, 1 ;Affect + cmp dword [ebp-4], 1 ;JumpIfEqual 1 + je l5 ;JumpIfEqual 2 + mov eax, 0 ;Affect +l5 : cmp eax, 0 ;JumpIfEqual 1 + je l4 ;JumpIfEqual 2 + mov dword [ebp-4], 0 ;Affect + mov dword [ebp-8], 0 ;Affect +l6 : mov eax, dword [ebp-12] + sub eax, 1 + mov ebx, 1 ;Affect + cmp dword [ebp-8], eax ;JumpIfLess 1 + jl l8 ;JumpIfLess 2 + mov ebx, 0 ;Affect +l8 : cmp ebx, 0 ;JumpIfEqual 1 + je l7 ;JumpIfEqual 2 + mov ebx, dword [ebp-8] + add ebx, 1 + mov eax, 1 ;Affect + mov ebx, ebx + imul ebx, 4 + mov ecx, dword [ebp-8] + imul ecx, 4 + mov ebx, dword [tab+ebx] ;JumpIfLess 1 + cmp ebx, dword [tab+ecx] ;on passe par un registre temporaire + jl l11 ;JumpIfLess 2 + mov eax, 0 ;Affect +l11 : cmp eax, 0 ;JumpIfEqual 1 + je l10 ;JumpIfEqual 2 + push dword [ebp-8] ;Param + mov eax, dword [ebp-8] + add eax, 1 + push eax ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call echanger + pop eax ;récupération de la valeur de retour + add esp, 8 ;désallocation des arguments + mov dword [ebp-4], 1 ;Affect +l10 : mov eax, dword [ebp-8] + add eax, 1 + mov dword [ebp-8], eax ;Affect + jmp l6 ;Jump +l7 : mov eax, dword [ebp-12] + sub eax, 1 + mov dword [ebp-12], eax ;Affect + jmp l3 ;Jump +l4 : add esp, 12 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call initialiser + pop eax ;récupération de la valeur de retour + push 10 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call afficher + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + push 10 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call trier + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + push 10 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call afficher + pop eax ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varglob1.nasm b/test/nasm-ref/varglob1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f2d6bb521d13b69045c307f12b9e81348baa3641 --- /dev/null +++ b/test/nasm-ref/varglob1.nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +variable : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [variable], 6834 ;Affect + mov eax, dword [variable] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varglob2.nasm b/test/nasm-ref/varglob2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..0d3aa1a3bca6108ca17fe9b50da63c1ace553650 --- /dev/null +++ b/test/nasm-ref/varglob2.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +variable : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [variable], 10 ;Affect + mov eax, dword [variable] + add eax, 50 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varglob3.nasm b/test/nasm-ref/varglob3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..3e82be48c92841b4976cf0fffc764208e911726b --- /dev/null +++ b/test/nasm-ref/varglob3.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +var2 : resd 4 ;variable globale +var1 : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [var1], 10 ;Affect + mov dword [var2], 34 ;Affect + mov eax, dword [var1] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [var2] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varglob4.nasm b/test/nasm-ref/varglob4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..426256a88109e0f882b83372a0635a2588731d4e --- /dev/null +++ b/test/nasm-ref/varglob4.nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +var2 : resd 4 ;variable globale +var1 : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [var1], 10 ;Affect + mov dword [var2], 34 ;Affect + mov eax, dword [var1] + add eax, dword [var2] + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varloc1.nasm b/test/nasm-ref/varloc1.nasm new file mode 100644 index 0000000000000000000000000000000000000000..f16e7b409d9e4b872dfccfb45e8e69fa21ba19a1 --- /dev/null +++ b/test/nasm-ref/varloc1.nasm @@ -0,0 +1,31 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 6834 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varloc2.nasm b/test/nasm-ref/varloc2.nasm new file mode 100644 index 0000000000000000000000000000000000000000..6fa1b7fd362a189759c978fd86059e00ed63559c --- /dev/null +++ b/test/nasm-ref/varloc2.nasm @@ -0,0 +1,33 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov eax, dword [ebp-4] + add eax, 50 + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varloc3.nasm b/test/nasm-ref/varloc3.nasm new file mode 100644 index 0000000000000000000000000000000000000000..821c6cd33f1f8a3cfb2863eb81590e67f9d6c2ba --- /dev/null +++ b/test/nasm-ref/varloc3.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov dword [ebp-8], 30 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp-8] ;Write 1 + call iprintLF ;Write 2 + add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varloc4.nasm b/test/nasm-ref/varloc4.nasm new file mode 100644 index 0000000000000000000000000000000000000000..931ea5887a9c95b25affb1d4ff2dec5a91fdff8b --- /dev/null +++ b/test/nasm-ref/varloc4.nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov dword [ebp-8], 30 ;Affect + mov eax, dword [ebp-4] + add eax, dword [ebp-8] + mov eax, eax ;Write 1 + call iprintLF ;Write 2 + add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/nasm-ref/varloc5.nasm b/test/nasm-ref/varloc5.nasm new file mode 100644 index 0000000000000000000000000000000000000000..58b8668461824e8d54f75b605d3a4543d37fc01b --- /dev/null +++ b/test/nasm-ref/varloc5.nasm @@ -0,0 +1,52 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +var1 : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop eax ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [var1], 20 ;Affect + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop eax ;récupération de la valeur de retour + mov eax, dword [var1] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/out-ref/add1.out b/test/out-ref/add1.out new file mode 100644 index 0000000000000000000000000000000000000000..b1bd38b62a0800a4f6a80c34e21c5acffae52c7e --- /dev/null +++ b/test/out-ref/add1.out @@ -0,0 +1 @@ +13 diff --git a/test/out-ref/add2.out b/test/out-ref/add2.out new file mode 100644 index 0000000000000000000000000000000000000000..8351c19397f4fcd5238d10034fa7fa384f14d580 --- /dev/null +++ b/test/out-ref/add2.out @@ -0,0 +1 @@ +14 diff --git a/test/out-ref/affect1.out b/test/out-ref/affect1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/affect1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/affect2.out b/test/out-ref/affect2.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/affect2.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/affect3.out b/test/out-ref/affect3.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/affect3.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/and1.out b/test/out-ref/and1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/and1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/and2.out b/test/out-ref/and2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/and2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/and3.out b/test/out-ref/and3.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/and3.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/and4.out b/test/out-ref/and4.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/and4.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/and5.out b/test/out-ref/and5.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/and5.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/appel-param1.out b/test/out-ref/appel-param1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/appel-param1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/appel-param2.out b/test/out-ref/appel-param2.out new file mode 100644 index 0000000000000000000000000000000000000000..fe3862e97aff6431de7f25a36a96f784da747858 --- /dev/null +++ b/test/out-ref/appel-param2.out @@ -0,0 +1,2 @@ +1 +456 diff --git a/test/out-ref/appel-param3.out b/test/out-ref/appel-param3.out new file mode 100644 index 0000000000000000000000000000000000000000..8a1218a1024a212bb3db30becd860315f9f3ac52 --- /dev/null +++ b/test/out-ref/appel-param3.out @@ -0,0 +1,5 @@ +1 +2 +3 +4 +5 diff --git a/test/out-ref/appel-retour1.out b/test/out-ref/appel-retour1.out new file mode 100644 index 0000000000000000000000000000000000000000..810283d091520435fc538cacd1218df2a2b8e706 --- /dev/null +++ b/test/out-ref/appel-retour1.out @@ -0,0 +1 @@ +3712 diff --git a/test/out-ref/appel1.out b/test/out-ref/appel1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/appel1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/appel2.out b/test/out-ref/appel2.out new file mode 100644 index 0000000000000000000000000000000000000000..1191247b6d9a206f6ba3d8ac79e26d041dd86941 --- /dev/null +++ b/test/out-ref/appel2.out @@ -0,0 +1,2 @@ +1 +2 diff --git a/test/out-ref/appel3.out b/test/out-ref/appel3.out new file mode 100644 index 0000000000000000000000000000000000000000..1191247b6d9a206f6ba3d8ac79e26d041dd86941 --- /dev/null +++ b/test/out-ref/appel3.out @@ -0,0 +1,2 @@ +1 +2 diff --git a/test/out-ref/div1.out b/test/out-ref/div1.out new file mode 100644 index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f --- /dev/null +++ b/test/out-ref/div1.out @@ -0,0 +1 @@ +2 diff --git a/test/out-ref/div2.out b/test/out-ref/div2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/div2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/div3.out b/test/out-ref/div3.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/div3.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/div4.out b/test/out-ref/div4.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/div4.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/ecrire1.out b/test/out-ref/ecrire1.out new file mode 100644 index 0000000000000000000000000000000000000000..169efa8bd26e4837bafefa6e14c2abee4541f6bc --- /dev/null +++ b/test/out-ref/ecrire1.out @@ -0,0 +1 @@ +3456 diff --git a/test/out-ref/ecrire2.out b/test/out-ref/ecrire2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/ecrire2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/egal1.out b/test/out-ref/egal1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/egal1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/egal2.out b/test/out-ref/egal2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/egal2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/egal3.out b/test/out-ref/egal3.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/egal3.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/err5.out b/test/out-ref/err5.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/err5.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/fibo.out b/test/out-ref/fibo.out new file mode 100644 index 0000000000000000000000000000000000000000..c3f407c0955bb5738e40a82664c79b63f04a9adb --- /dev/null +++ b/test/out-ref/fibo.out @@ -0,0 +1 @@ +55 diff --git a/test/out-ref/inf1.out b/test/out-ref/inf1.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/inf1.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/inf2.out b/test/out-ref/inf2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/inf2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/inf3.out b/test/out-ref/inf3.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/inf3.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/inf4.out b/test/out-ref/inf4.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/inf4.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/mult1.out b/test/out-ref/mult1.out new file mode 100644 index 0000000000000000000000000000000000000000..1e8b314962144c26d5e0e50fd29d2ca327864913 --- /dev/null +++ b/test/out-ref/mult1.out @@ -0,0 +1 @@ +6 diff --git a/test/out-ref/mult2.out b/test/out-ref/mult2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/mult2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/mult3.out b/test/out-ref/mult3.out new file mode 100644 index 0000000000000000000000000000000000000000..3c032078a4a21c5c51d3c93d91717c1dabbb8cd0 --- /dev/null +++ b/test/out-ref/mult3.out @@ -0,0 +1 @@ +18 diff --git a/test/out-ref/not1.out b/test/out-ref/not1.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/not1.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/not2.out b/test/out-ref/not2.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/not2.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/not3.out b/test/out-ref/not3.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/not3.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/or1.out b/test/out-ref/or1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/or1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/or2.out b/test/out-ref/or2.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/or2.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/or3.out b/test/out-ref/or3.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/or3.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/or4.out b/test/out-ref/or4.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/or4.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/or5.out b/test/out-ref/or5.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/or5.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/parenth1.out b/test/out-ref/parenth1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/parenth1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/parenth2.out b/test/out-ref/parenth2.out new file mode 100644 index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f --- /dev/null +++ b/test/out-ref/parenth2.out @@ -0,0 +1 @@ +2 diff --git a/test/out-ref/prio23-1.out b/test/out-ref/prio23-1.out new file mode 100644 index 0000000000000000000000000000000000000000..f599e28b8ab0d8c9c57a486c89c4a5132dcbd3b2 --- /dev/null +++ b/test/out-ref/prio23-1.out @@ -0,0 +1 @@ +10 diff --git a/test/out-ref/prio23-2.out b/test/out-ref/prio23-2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/prio23-2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/prio23-3.out b/test/out-ref/prio23-3.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/prio23-3.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/prio23-4.out b/test/out-ref/prio23-4.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/prio23-4.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/prio34-1.out b/test/out-ref/prio34-1.out new file mode 100644 index 0000000000000000000000000000000000000000..8351c19397f4fcd5238d10034fa7fa384f14d580 --- /dev/null +++ b/test/out-ref/prio34-1.out @@ -0,0 +1 @@ +14 diff --git a/test/out-ref/prio34-2.out b/test/out-ref/prio34-2.out new file mode 100644 index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f --- /dev/null +++ b/test/out-ref/prio34-2.out @@ -0,0 +1 @@ +2 diff --git a/test/out-ref/prio34-3.out b/test/out-ref/prio34-3.out new file mode 100644 index 0000000000000000000000000000000000000000..6446481c167171aff70c87e1568d957769e38bc3 --- /dev/null +++ b/test/out-ref/prio34-3.out @@ -0,0 +1 @@ +-70 diff --git a/test/out-ref/prio34-4.out b/test/out-ref/prio34-4.out new file mode 100644 index 0000000000000000000000000000000000000000..45a4fb75db864000d01701c0f7a51864bd4daabf --- /dev/null +++ b/test/out-ref/prio34-4.out @@ -0,0 +1 @@ +8 diff --git a/test/out-ref/prio45-1.out b/test/out-ref/prio45-1.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/prio45-1.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/prio45-2.out b/test/out-ref/prio45-2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/prio45-2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/prio45-3.out b/test/out-ref/prio45-3.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/prio45-3.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/prio45-4.out b/test/out-ref/prio45-4.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/prio45-4.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/prio56-1.out b/test/out-ref/prio56-1.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/prio56-1.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/prio56-2.out b/test/out-ref/prio56-2.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/prio56-2.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/prio67-1.out b/test/out-ref/prio67-1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/prio67-1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/prio67-2.out b/test/out-ref/prio67-2.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/prio67-2.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/rec1.out b/test/out-ref/rec1.out new file mode 100644 index 0000000000000000000000000000000000000000..29d6383b52c1352e92a45875b5bb206f89139643 --- /dev/null +++ b/test/out-ref/rec1.out @@ -0,0 +1 @@ +100 diff --git a/test/out-ref/si1.out b/test/out-ref/si1.out new file mode 100644 index 0000000000000000000000000000000000000000..d00491fd7e5bb6fa28c517a0bb32b8b506539d4d --- /dev/null +++ b/test/out-ref/si1.out @@ -0,0 +1 @@ +1 diff --git a/test/out-ref/si2.out b/test/out-ref/si2.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/si2.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/si3.out b/test/out-ref/si3.out new file mode 100644 index 0000000000000000000000000000000000000000..6ed281c757a969ffe22f3dcfa5830c532479c726 --- /dev/null +++ b/test/out-ref/si3.out @@ -0,0 +1,2 @@ +1 +1 diff --git a/test/out-ref/si4.out b/test/out-ref/si4.out new file mode 100644 index 0000000000000000000000000000000000000000..0d66ea1aee9527bfa39185ead1f9cdbd96bba88c --- /dev/null +++ b/test/out-ref/si4.out @@ -0,0 +1,2 @@ +0 +1 diff --git a/test/out-ref/si5.out b/test/out-ref/si5.out new file mode 100644 index 0000000000000000000000000000000000000000..e8183f05f5db68b3934e93f4bf6bed2bb664e0b5 --- /dev/null +++ b/test/out-ref/si5.out @@ -0,0 +1,3 @@ +1 +1 +1 diff --git a/test/out-ref/sub1.out b/test/out-ref/sub1.out new file mode 100644 index 0000000000000000000000000000000000000000..7ed6ff82de6bcc2a78243fc9c54d3ef5ac14da69 --- /dev/null +++ b/test/out-ref/sub1.out @@ -0,0 +1 @@ +5 diff --git a/test/out-ref/sub2.out b/test/out-ref/sub2.out new file mode 100644 index 0000000000000000000000000000000000000000..995f07c1771038b195c79e1bc5ab02d3afd24365 --- /dev/null +++ b/test/out-ref/sub2.out @@ -0,0 +1 @@ +-13 diff --git a/test/out-ref/sub3.out b/test/out-ref/sub3.out new file mode 100644 index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56 --- /dev/null +++ b/test/out-ref/sub3.out @@ -0,0 +1 @@ +0 diff --git a/test/out-ref/tab1.out b/test/out-ref/tab1.out new file mode 100644 index 0000000000000000000000000000000000000000..4539bbf2d22d5c3b4227859ff854eda060a687fb --- /dev/null +++ b/test/out-ref/tab1.out @@ -0,0 +1,3 @@ +0 +1 +2 diff --git a/test/out-ref/tab2.out b/test/out-ref/tab2.out new file mode 100644 index 0000000000000000000000000000000000000000..ecfe662f10f360d0149e928b84dbf433e56ce3bd --- /dev/null +++ b/test/out-ref/tab2.out @@ -0,0 +1,3 @@ +34 +74 +16 diff --git a/test/out-ref/tab3.out b/test/out-ref/tab3.out new file mode 100644 index 0000000000000000000000000000000000000000..ecfe662f10f360d0149e928b84dbf433e56ce3bd --- /dev/null +++ b/test/out-ref/tab3.out @@ -0,0 +1,3 @@ +34 +74 +16 diff --git a/test/out-ref/tab4.out b/test/out-ref/tab4.out new file mode 100644 index 0000000000000000000000000000000000000000..fa56b0b3ea69abbe8ff34c4b602e7f66b06c6b1a --- /dev/null +++ b/test/out-ref/tab4.out @@ -0,0 +1,3 @@ +1 +12 +13 diff --git a/test/out-ref/tantque1.out b/test/out-ref/tantque1.out new file mode 100644 index 0000000000000000000000000000000000000000..30b148df5474850ce0add0d62d9e1aa76c84293f --- /dev/null +++ b/test/out-ref/tantque1.out @@ -0,0 +1,11 @@ +10 +9 +8 +7 +6 +5 +4 +3 +2 +1 +0 diff --git a/test/out-ref/tantque2.out b/test/out-ref/tantque2.out new file mode 100644 index 0000000000000000000000000000000000000000..4ee1d372736b4de691e829a3b53a0acccc95411c --- /dev/null +++ b/test/out-ref/tantque2.out @@ -0,0 +1,32 @@ +0 +0 +0 +1 +0 +2 +0 +3 +1 +0 +1 +1 +1 +2 +1 +3 +2 +0 +2 +1 +2 +2 +2 +3 +3 +0 +3 +1 +3 +2 +3 +3 diff --git a/test/out-ref/tri.out b/test/out-ref/tri.out new file mode 100644 index 0000000000000000000000000000000000000000..d32f608d46a00bc248c8d9d9570fcaacd4b33de7 --- /dev/null +++ b/test/out-ref/tri.out @@ -0,0 +1,22 @@ +8 +6 +9 +9 +4 +2 +3 +1 +4 +5 +0 +1 +2 +3 +4 +4 +5 +6 +8 +9 +9 +0 diff --git a/test/out-ref/varglob1.out b/test/out-ref/varglob1.out new file mode 100644 index 0000000000000000000000000000000000000000..0f94b342b49eb656ef0db53ce65dfb6092f5678f --- /dev/null +++ b/test/out-ref/varglob1.out @@ -0,0 +1 @@ +6834 diff --git a/test/out-ref/varglob2.out b/test/out-ref/varglob2.out new file mode 100644 index 0000000000000000000000000000000000000000..abdfb053e41e2af75ba7e11f82b4ef0c312566a7 --- /dev/null +++ b/test/out-ref/varglob2.out @@ -0,0 +1 @@ +60 diff --git a/test/out-ref/varglob3.out b/test/out-ref/varglob3.out new file mode 100644 index 0000000000000000000000000000000000000000..8ba133e658309023e62c05c237929c3078b8967a --- /dev/null +++ b/test/out-ref/varglob3.out @@ -0,0 +1,2 @@ +10 +34 diff --git a/test/out-ref/varglob4.out b/test/out-ref/varglob4.out new file mode 100644 index 0000000000000000000000000000000000000000..c739b42c4d2ce23786c5350641d0adbf5fa7d6b2 --- /dev/null +++ b/test/out-ref/varglob4.out @@ -0,0 +1 @@ +44 diff --git a/test/out-ref/varloc1.out b/test/out-ref/varloc1.out new file mode 100644 index 0000000000000000000000000000000000000000..0f94b342b49eb656ef0db53ce65dfb6092f5678f --- /dev/null +++ b/test/out-ref/varloc1.out @@ -0,0 +1 @@ +6834 diff --git a/test/out-ref/varloc2.out b/test/out-ref/varloc2.out new file mode 100644 index 0000000000000000000000000000000000000000..abdfb053e41e2af75ba7e11f82b4ef0c312566a7 --- /dev/null +++ b/test/out-ref/varloc2.out @@ -0,0 +1 @@ +60 diff --git a/test/out-ref/varloc3.out b/test/out-ref/varloc3.out new file mode 100644 index 0000000000000000000000000000000000000000..3d1851ccebea47571d78882cecb31cc6c89b85d2 --- /dev/null +++ b/test/out-ref/varloc3.out @@ -0,0 +1,2 @@ +10 +30 diff --git a/test/out-ref/varloc4.out b/test/out-ref/varloc4.out new file mode 100644 index 0000000000000000000000000000000000000000..425151f3a411f5e088d7753e7c8d016303b1b9d1 --- /dev/null +++ b/test/out-ref/varloc4.out @@ -0,0 +1 @@ +40 diff --git a/test/out-ref/varloc5.out b/test/out-ref/varloc5.out new file mode 100644 index 0000000000000000000000000000000000000000..3b86147b3542fae0e5e4cdb03bd17a50cf7e758f --- /dev/null +++ b/test/out-ref/varloc5.out @@ -0,0 +1,2 @@ +10 +20 diff --git a/test/pre-nasm-ref/add1.pre-nasm b/test/pre-nasm-ref/add1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..a85129f01a46f39ffc46fbec4b86c2d20a75a261 --- /dev/null +++ b/test/pre-nasm-ref/add1.pre-nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 3 + add @1, 10 + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/add2.pre-nasm b/test/pre-nasm-ref/add2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..c32aa25720276d0f6670fd49f058f6ad0dc390b2 --- /dev/null +++ b/test/pre-nasm-ref/add2.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 2 + add @1, 4 + mov @2, @1 + add @2, 8 + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/affect1.pre-nasm b/test/pre-nasm-ref/affect1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..58fe6a9c7656d16c7e212374b07f6446bb5458de --- /dev/null +++ b/test/pre-nasm-ref/affect1.pre-nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +a : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [a], 1 ;Affect + mov eax, dword [a] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/affect2.pre-nasm b/test/pre-nasm-ref/affect2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..c5e4bb771f15ed9880bf2eb9a4d3eac151665b54 --- /dev/null +++ b/test/pre-nasm-ref/affect2.pre-nasm @@ -0,0 +1,31 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 1 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/affect3.pre-nasm b/test/pre-nasm-ref/affect3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..cad08c4c12780a20722d1110fec348ccb03db02b --- /dev/null +++ b/test/pre-nasm-ref/affect3.pre-nasm @@ -0,0 +1,50 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [ebp+12], 1 ;Affect + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + push 3 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/and1.pre-nasm b/test/pre-nasm-ref/and1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..13ff14a63e3ff3294d8e586405463c7506d587f8 --- /dev/null +++ b/test/pre-nasm-ref/and1.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 1 ;JumpIfEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @9, 1 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @1, 1 ;Affect + jmp l0 ;Jump +l1 : mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/and2.pre-nasm b/test/pre-nasm-ref/and2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..cc749c501293dd723111bbf8f696c9b5ff80b397 --- /dev/null +++ b/test/pre-nasm-ref/and2.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 1 ;JumpIfEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @9, 0 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @1, 1 ;Affect + jmp l0 ;Jump +l1 : mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/and3.pre-nasm b/test/pre-nasm-ref/and3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..96293418ed3365cd83127d61d8490e88a513339c --- /dev/null +++ b/test/pre-nasm-ref/and3.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 0 ;JumpIfEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @9, 1 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @1, 1 ;Affect + jmp l0 ;Jump +l1 : mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/and4.pre-nasm b/test/pre-nasm-ref/and4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..99c1ee1bbb1427e04c5cd28def80cfe306daeeb5 --- /dev/null +++ b/test/pre-nasm-ref/and4.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 0 ;JumpIfEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @9, 0 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @1, 1 ;Affect + jmp l0 ;Jump +l1 : mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/and5.pre-nasm b/test/pre-nasm-ref/and5.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..cace673b5854a9f1bf5e078c297cd1ab8ffc60b4 --- /dev/null +++ b/test/pre-nasm-ref/and5.pre-nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @9, 1 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov @10, 0 ;JumpIfEqual 1 + cmp @10, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov @2, 1 ;Affect + jmp l2 ;Jump +l3 : mov @2, 0 ;Affect +l2 : cmp @2, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov @11, 1 ;JumpIfEqual 1 + cmp @11, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @1, 1 ;Affect + jmp l0 ;Jump +l1 : mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/appel-param1.pre-nasm b/test/pre-nasm-ref/appel-param1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..fd584ca3b762727a5d8c38cf4a7cce5b5e5ce5de --- /dev/null +++ b/test/pre-nasm-ref/appel-param1.pre-nasm @@ -0,0 +1,49 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 1 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/appel-param2.pre-nasm b/test/pre-nasm-ref/appel-param2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..1a57087c0f9b9f6173528a391620d50bba781922 --- /dev/null +++ b/test/pre-nasm-ref/appel-param2.pre-nasm @@ -0,0 +1,52 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, dword [ebp+16] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 1 ;Param + push 456 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + add esp, 8 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/appel-param3.pre-nasm b/test/pre-nasm-ref/appel-param3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..78e7ab7a31e139612972392c36e87c2e3ed2ad94 --- /dev/null +++ b/test/pre-nasm-ref/appel-param3.pre-nasm @@ -0,0 +1,61 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, dword [ebp+28] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+24] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+20] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+16] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp+12] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 1 ;Param + push 2 ;Param + push 3 ;Param + push 4 ;Param + push 5 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + add esp, 20 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/appel-retour1.pre-nasm b/test/pre-nasm-ref/appel-retour1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..08411802c832b988ee0d165f1dd6b528d8b31215 --- /dev/null +++ b/test/pre-nasm-ref/appel-retour1.pre-nasm @@ -0,0 +1,58 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, dword [ebp+12] ;ecriture de la valeur de retour + mov dword [ebp+8], @8 ;on passe par un registre temporaire + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 3712 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/appel1.pre-nasm b/test/pre-nasm-ref/appel1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..ff0343548b797b307f8b9de344ea817f2746b97c --- /dev/null +++ b/test/pre-nasm-ref/appel1.pre-nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/appel2.pre-nasm b/test/pre-nasm-ref/appel2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..354f57911a6b0a70f5ea73401f3be3e54df86d39 --- /dev/null +++ b/test/pre-nasm-ref/appel2.pre-nasm @@ -0,0 +1,66 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +g : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + sub esp, 4 ;allocation mémoire pour la valeur de retour + call g + pop @1 ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @2 ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/appel3.pre-nasm b/test/pre-nasm-ref/appel3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..6246b00713e3a10576bd1b0d66b2b3576497b30b --- /dev/null +++ b/test/pre-nasm-ref/appel3.pre-nasm @@ -0,0 +1,66 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +g : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + sub esp, 4 ;allocation mémoire pour la valeur de retour + call g + pop @2 ;récupération de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/div1.pre-nasm b/test/pre-nasm-ref/div1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..fdbadf0f339b8e7d2389c94c4c386b8bcae75b54 --- /dev/null +++ b/test/pre-nasm-ref/div1.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 4 ;affectation des bits de poids faible du dividende + mov @10, 2 + idiv @10 + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov @1, eax + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/div2.pre-nasm b/test/pre-nasm-ref/div2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..03e43c72a99ebb878e7ab26f547032fe242d892c --- /dev/null +++ b/test/pre-nasm-ref/div2.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 0 ;affectation des bits de poids faible du dividende + mov @10, 712 + idiv @10 + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov @1, eax + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/div3.pre-nasm b/test/pre-nasm-ref/div3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..27cec5c12aca50fbe09922d90e117b91aee31786 --- /dev/null +++ b/test/pre-nasm-ref/div3.pre-nasm @@ -0,0 +1,42 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 4 ;affectation des bits de poids faible du dividende + mov @11, 2 + idiv @11 + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov @1, eax + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, @1 ;affectation des bits de poids faible du dividende + mov @15, 2 + idiv @15 + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov @2, eax + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/div4.pre-nasm b/test/pre-nasm-ref/div4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..af05666e3cadda5d0708be05ca608faa57e7bc8d --- /dev/null +++ b/test/pre-nasm-ref/div4.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 2 ;affectation des bits de poids faible du dividende + mov @10, 3 + idiv @10 + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov @1, eax + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/ecrire1.pre-nasm b/test/pre-nasm-ref/ecrire1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..e49a65c2c56dde7f3c493b52ecaa50c8f0f4fdb7 --- /dev/null +++ b/test/pre-nasm-ref/ecrire1.pre-nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 3456 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/ecrire2.pre-nasm b/test/pre-nasm-ref/ecrire2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..cf9c03969b909c4d332871be32365b0194805485 --- /dev/null +++ b/test/pre-nasm-ref/ecrire2.pre-nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 0 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/egal1.pre-nasm b/test/pre-nasm-ref/egal1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..427c6ce89c732fb3b2b497840c8b01e98da91f93 --- /dev/null +++ b/test/pre-nasm-ref/egal1.pre-nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + mov @8, 123 ;JumpIfEqual 1 + cmp @8, 123 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/egal2.pre-nasm b/test/pre-nasm-ref/egal2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..b85f93d7efd769ee3991c1a94dc1899ba1fa467e --- /dev/null +++ b/test/pre-nasm-ref/egal2.pre-nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + mov @8, 412 ;JumpIfEqual 1 + cmp @8, 34 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/egal3.pre-nasm b/test/pre-nasm-ref/egal3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..e0e2b8979b0ebe85f68eb9fd5415d2c75d06729b --- /dev/null +++ b/test/pre-nasm-ref/egal3.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 1 ;Affect + mov @9, 2 ;JumpIfEqual 1 + cmp @9, 2 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @2, 0 ;Affect +l1 : mov @1, 1 ;Affect + cmp @2, 1 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/fibo.pre-nasm b/test/pre-nasm-ref/fibo.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..bea531a62c6829c395621108469648e4d03f58e6 --- /dev/null +++ b/test/pre-nasm-ref/fibo.pre-nasm @@ -0,0 +1,88 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +fibo : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + cmp dword [ebp+12], 2 ;JumpIfLess 1 + jl l2 ;JumpIfLess 2 + mov @1, 0 ;Affect +l2 : cmp @1, 0 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov dword [ebp+8], 1 ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret + jmp l1 ;Jump +l0 : mov @3, dword [ebp+12] + sub @3, 1 + push @3 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call fibo + pop @2 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov @5, dword [ebp+12] + sub @5, 2 + push @5 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call fibo + pop @4 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov @6, @2 + add @6, @4 + mov dword [ebp+8], @6 ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 9 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call fibo + pop @7 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, @7 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/inf1.pre-nasm b/test/pre-nasm-ref/inf1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..a0f0f2d5929b5d38452b53dff981e35b1cc78dc5 --- /dev/null +++ b/test/pre-nasm-ref/inf1.pre-nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + mov @8, 3 ;JumpIfLess 1 + cmp @8, 3 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/inf2.pre-nasm b/test/pre-nasm-ref/inf2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..acd3a8aa9251fa288b037d29c6209f1224d98369 --- /dev/null +++ b/test/pre-nasm-ref/inf2.pre-nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + mov @8, 4 ;JumpIfLess 1 + cmp @8, 1 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/inf3.pre-nasm b/test/pre-nasm-ref/inf3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..eadc985c2c4e9c00f67c32d3c7d6a4ef77ff1884 --- /dev/null +++ b/test/pre-nasm-ref/inf3.pre-nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + mov @8, 312 ;JumpIfLess 1 + cmp @8, 475 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/inf4.pre-nasm b/test/pre-nasm-ref/inf4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..9c902817bf8ba6e5d6d8f8f6c2870709f7360c2a --- /dev/null +++ b/test/pre-nasm-ref/inf4.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop r0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov r2, 1 ;Affect + mov r9, 3 ;JumpIfLess 1 + cmp r9, 2 ;on passe par un registre temporaire + jl l1 ;JumpIfLess 2 + mov r2, 0 ;Affect +l1 : mov r1, 1 ;Affect + cmp r2, 1 ;JumpIfLess 1 + jl l0 ;JumpIfLess 2 + mov r1, 0 ;Affect +l0 : mov eax, r1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/pre-nasm-ref/mult1.pre-nasm b/test/pre-nasm-ref/mult1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..1986d14e99fd6413fb9eefae9b2330619e6456d7 --- /dev/null +++ b/test/pre-nasm-ref/mult1.pre-nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 2 + imul @1, 3 + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/mult2.pre-nasm b/test/pre-nasm-ref/mult2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..28d48a3b88e06ee39a96ad70965f1c3989361ff5 --- /dev/null +++ b/test/pre-nasm-ref/mult2.pre-nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 0 + imul @1, 321 + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/mult3.pre-nasm b/test/pre-nasm-ref/mult3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..d9fbcbfa6b97564ff9538ab85c815a1e9c0e22de --- /dev/null +++ b/test/pre-nasm-ref/mult3.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 3 + imul @1, 3 + mov @2, @1 + imul @2, 2 + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/not1.pre-nasm b/test/pre-nasm-ref/not1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..eb7b79fa8b7b1d2db8942909986bdf0e154910f9 --- /dev/null +++ b/test/pre-nasm-ref/not1.pre-nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + mov @8, 1 ;JumpIfEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/not2.pre-nasm b/test/pre-nasm-ref/not2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..2c7a875fad04782613a4720f599a61096add6925 --- /dev/null +++ b/test/pre-nasm-ref/not2.pre-nasm @@ -0,0 +1,35 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + mov @8, 0 ;JumpIfEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/not3.pre-nasm b/test/pre-nasm-ref/not3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..f523d4f60a877729ef863a3f1a60623a9a203481 --- /dev/null +++ b/test/pre-nasm-ref/not3.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 1 ;Affect + mov @9, 0 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @2, 0 ;Affect +l1 : mov @1, 1 ;Affect + cmp @2, 0 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/or1.pre-nasm b/test/pre-nasm-ref/or1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..2e6687614c1bd1d91c4c03f52646d3a6742ff6e4 --- /dev/null +++ b/test/pre-nasm-ref/or1.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 1 ;jumpIfNotEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @9, 1 ;jumpIfNotEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/or2.pre-nasm b/test/pre-nasm-ref/or2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..600dd181e20fea10cfc8beb8bc63e6d483fe6897 --- /dev/null +++ b/test/pre-nasm-ref/or2.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 1 ;jumpIfNotEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @9, 0 ;jumpIfNotEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/or3.pre-nasm b/test/pre-nasm-ref/or3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..f34edd4ae4d67b2dec40ed2edb8da4e67c884c5d --- /dev/null +++ b/test/pre-nasm-ref/or3.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 0 ;jumpIfNotEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @9, 1 ;jumpIfNotEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/or4.pre-nasm b/test/pre-nasm-ref/or4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..becebcc19701bd45c79fdd3f44cfc1730cad7fec --- /dev/null +++ b/test/pre-nasm-ref/or4.pre-nasm @@ -0,0 +1,39 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 0 ;jumpIfNotEqual 1 + cmp @8, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @9, 0 ;jumpIfNotEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/or5.pre-nasm b/test/pre-nasm-ref/or5.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..46e2785cb0cb91abca24b53648b05d420273b96e --- /dev/null +++ b/test/pre-nasm-ref/or5.pre-nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @9, 0 ;jumpIfNotEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + jne l3 ;jumpIfNotEqual 2 + mov @10, 1 ;jumpIfNotEqual 1 + cmp @10, 0 ;on passe par un registre temporaire + jne l3 ;jumpIfNotEqual 2 + mov @2, 0 ;Affect + jmp l2 ;Jump +l3 : mov @2, 1 ;Affect +l2 : cmp @2, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov @11, 0 ;jumpIfNotEqual 1 + cmp @11, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/parenth1.pre-nasm b/test/pre-nasm-ref/parenth1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..27b03b80c36b05cb2041895ba422f7d674f2b540 --- /dev/null +++ b/test/pre-nasm-ref/parenth1.pre-nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/parenth2.pre-nasm b/test/pre-nasm-ref/parenth2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..8673e3935727a981e0fec8e8f2e18a336821872e --- /dev/null +++ b/test/pre-nasm-ref/parenth2.pre-nasm @@ -0,0 +1,30 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov eax, 2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio23-1.pre-nasm b/test/pre-nasm-ref/prio23-1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..8011242044c9f3aa28b968b329998a24a7eed909 --- /dev/null +++ b/test/pre-nasm-ref/prio23-1.pre-nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop r0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov r1, 1 ;Affect + mov r9, 0 ;JumpIfEqual 1 + cmp r9, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov r1, 0 ;Affect +l0 : mov r2, r1 ; + imul r2, 10 ; + mov eax, r2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/pre-nasm-ref/prio23-2.pre-nasm b/test/pre-nasm-ref/prio23-2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..762181d13b6371a1b8b87bcd0d7a96c575c516dd --- /dev/null +++ b/test/pre-nasm-ref/prio23-2.pre-nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop r0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov r1, 1 ;Affect + mov r9, 10 ;JumpIfEqual 1 + cmp r9, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov r1, 0 ;Affect +l0 : mov r2, 3 ; + imul r2, r1 ; + mov eax, r2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/pre-nasm-ref/prio23-3.pre-nasm b/test/pre-nasm-ref/prio23-3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..2892dc2e2242915e04687493b5fea7785e727c2d --- /dev/null +++ b/test/pre-nasm-ref/prio23-3.pre-nasm @@ -0,0 +1,41 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop r0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov r1, 1 ;Affect + mov r9, 0 ;JumpIfEqual 1 + cmp r9, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov r1, 0 ;Affect +l0 : mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, r1 ;affectation des bits de poids faible du dividende + mov r12, 1 ; + idiv r12 ; + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov r2, eax ; + mov eax, r2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/pre-nasm-ref/prio23-4.pre-nasm b/test/pre-nasm-ref/prio23-4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..87dd906f38774319e773f04fc0b7c99d2e7df9d4 --- /dev/null +++ b/test/pre-nasm-ref/prio23-4.pre-nasm @@ -0,0 +1,45 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main ; + pop r0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 ; +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov r1, 1 ;Affect + mov r10, 1 ;JumpIfEqual 1 + cmp r10, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov r1, 0 ;Affect +l0 : mov r2, 1 ;Affect + mov r11, 0 ;JumpIfEqual 1 + cmp r11, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov r2, 0 ;Affect +l1 : mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, r1 ;affectation des bits de poids faible du dividende + idiv r2 ; + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov r3, eax ; + mov eax, r3 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret ; diff --git a/test/pre-nasm-ref/prio34-1.pre-nasm b/test/pre-nasm-ref/prio34-1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..f2da2ea9fd6ed737c3d194d3d42bfd614d31b176 --- /dev/null +++ b/test/pre-nasm-ref/prio34-1.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 3 + imul @1, 4 + mov @2, 2 + add @2, @1 + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio34-2.pre-nasm b/test/pre-nasm-ref/prio34-2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..b33bca19f590463fc894b9bec2139c12a034582f --- /dev/null +++ b/test/pre-nasm-ref/prio34-2.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 2 + imul @1, 3 + mov @2, @1 + sub @2, 4 + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio34-3.pre-nasm b/test/pre-nasm-ref/prio34-3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..844ca425a079f77797fa1f840954b9ddb67c11de --- /dev/null +++ b/test/pre-nasm-ref/prio34-3.pre-nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 6 ;affectation des bits de poids faible du dividende + mov @11, 3 + idiv @11 + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov @1, eax + mov @2, @1 + sub @2, 72 + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio34-4.pre-nasm b/test/pre-nasm-ref/prio34-4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..a7d271054f8e72de53df1001de4cb96899b55d79 --- /dev/null +++ b/test/pre-nasm-ref/prio34-4.pre-nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov edx, 0 ;mise à 0 des bits de poids fort du dividende + mov eax, 20 ;affectation des bits de poids faible du dividende + mov @11, 10 + idiv @11 + mov edx, edx ;rend explicite l'utilisation de edx pour ne pas que sa valeur soit modifiée + mov @1, eax + mov @2, 6 + add @2, @1 + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio45-1.pre-nasm b/test/pre-nasm-ref/prio45-1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..1fb4cb0005de6c1ce0dfc9ce58412ed20fc3ae5a --- /dev/null +++ b/test/pre-nasm-ref/prio45-1.pre-nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 0 + add @2, 1 + mov @1, 1 ;Affect + mov @9, 2 ;JumpIfEqual 1 + cmp @9, @2 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio45-2.pre-nasm b/test/pre-nasm-ref/prio45-2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..5e1095022b1c3d13ce896c5ebe25e85446be29af --- /dev/null +++ b/test/pre-nasm-ref/prio45-2.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 1 + add @2, 234 + mov @1, 1 ;Affect + cmp @2, 1 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio45-3.pre-nasm b/test/pre-nasm-ref/prio45-3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..d4ee4c1a548dafbb0a68addf94dfb538c67bd722 --- /dev/null +++ b/test/pre-nasm-ref/prio45-3.pre-nasm @@ -0,0 +1,37 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 11 + add @2, 100 + mov @1, 1 ;Affect + mov @9, 12 ;JumpIfLess 1 + cmp @9, @2 ;on passe par un registre temporaire + jl l0 ;JumpIfLess 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio45-4.pre-nasm b/test/pre-nasm-ref/prio45-4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..3ffda465db48ea9cb2e0621bcc42beba2eedea3b --- /dev/null +++ b/test/pre-nasm-ref/prio45-4.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 21 + sub @2, 21 + mov @1, 1 ;Affect + cmp @2, 1 ;JumpIfLess 1 + jl l0 ;JumpIfLess 2 + mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio56-1.pre-nasm b/test/pre-nasm-ref/prio56-1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..add9a0d94ae76b4ed31eeb612141e1b856b3b6a9 --- /dev/null +++ b/test/pre-nasm-ref/prio56-1.pre-nasm @@ -0,0 +1,43 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 1 ;Affect + mov @9, 1 ;JumpIfEqual 1 + cmp @9, 2 ;on passe par un registre temporaire + je l2 ;JumpIfEqual 2 + mov @2, 0 ;Affect +l2 : cmp @2, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov @10, 1 ;JumpIfEqual 1 + cmp @10, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov @1, 1 ;Affect + jmp l0 ;Jump +l1 : mov @1, 0 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio56-2.pre-nasm b/test/pre-nasm-ref/prio56-2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..563d1d62fd5d23b67f97e13012201f6362b72b98 --- /dev/null +++ b/test/pre-nasm-ref/prio56-2.pre-nasm @@ -0,0 +1,43 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @2, 1 ;Affect + mov @9, 0 ;JumpIfEqual 1 + cmp @9, 1 ;on passe par un registre temporaire + je l2 ;JumpIfEqual 2 + mov @2, 0 ;Affect +l2 : mov @10, 1 ;jumpIfNotEqual 1 + cmp @10, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + cmp @2, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio67-1.pre-nasm b/test/pre-nasm-ref/prio67-1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..b615ead245c061eb36b70a107530cd6a2f22a06b --- /dev/null +++ b/test/pre-nasm-ref/prio67-1.pre-nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @9, 0 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov @10, 1 ;JumpIfEqual 1 + cmp @10, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov @2, 1 ;Affect + jmp l2 ;Jump +l3 : mov @2, 0 ;Affect +l2 : cmp @2, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov @11, 1 ;jumpIfNotEqual 1 + cmp @11, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/prio67-2.pre-nasm b/test/pre-nasm-ref/prio67-2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..872c0592661fce73b40931a9983776caa350e4ae --- /dev/null +++ b/test/pre-nasm-ref/prio67-2.pre-nasm @@ -0,0 +1,47 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @9, 1 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov @10, 0 ;JumpIfEqual 1 + cmp @10, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov @2, 1 ;Affect + jmp l2 ;Jump +l3 : mov @2, 0 ;Affect +l2 : mov @11, 1 ;jumpIfNotEqual 1 + cmp @11, 0 ;on passe par un registre temporaire + jne l1 ;jumpIfNotEqual 2 + cmp @2, 0 ;jumpIfNotEqual 1 + jne l1 ;jumpIfNotEqual 2 + mov @1, 0 ;Affect + jmp l0 ;Jump +l1 : mov @1, 1 ;Affect +l0 : mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/rec1.pre-nasm b/test/pre-nasm-ref/rec1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..0e66dc7a641f9983636dd1aed479de7d19fc006e --- /dev/null +++ b/test/pre-nasm-ref/rec1.pre-nasm @@ -0,0 +1,81 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 1 ;Affect + cmp dword [ebp+12], 1 ;JumpIfEqual 1 + je l2 ;JumpIfEqual 2 + mov @1, 0 ;Affect +l2 : cmp @1, 0 ;JumpIfEqual 1 + je l0 ;JumpIfEqual 2 + mov dword [ebp+8], 1 ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret + jmp l1 ;Jump +l0 : mov @3, dword [ebp+12] + sub @3, 1 + push @3 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @2 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov @4, 1 + add @4, @2 + mov dword [ebp+8], @4 ;ecriture de la valeur de retour + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + push 100 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @5 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + mov eax, @5 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/si1.pre-nasm b/test/pre-nasm-ref/si1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..dc1e313e7eccac85ada45bbee22bcf6ceceb54f4 --- /dev/null +++ b/test/pre-nasm-ref/si1.pre-nasm @@ -0,0 +1,33 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @7, 1 ;JumpIfEqual 1 + cmp @7, 0 ;on passe par un registre temporaire + je l1 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/si2.pre-nasm b/test/pre-nasm-ref/si2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..4836fc5ca0b4c69c449a2f584ee2a7d246462886 --- /dev/null +++ b/test/pre-nasm-ref/si2.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @7, 0 ;JumpIfEqual 1 + cmp @7, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + jmp l1 ;Jump +l0 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 +l1 : add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/si3.pre-nasm b/test/pre-nasm-ref/si3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..c8bc79555743344c7f60bf3b113d3c5824d1d2f9 --- /dev/null +++ b/test/pre-nasm-ref/si3.pre-nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @7, 1 ;JumpIfEqual 1 + cmp @7, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + jmp l1 ;Jump +l0 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 +l1 : mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/si4.pre-nasm b/test/pre-nasm-ref/si4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..cac66d9105bed7eb1be97831d0f7bcbd3e0ce898 --- /dev/null +++ b/test/pre-nasm-ref/si4.pre-nasm @@ -0,0 +1,38 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @7, 0 ;JumpIfEqual 1 + cmp @7, 0 ;on passe par un registre temporaire + je l0 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + jmp l1 ;Jump +l0 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 +l1 : mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/si5.pre-nasm b/test/pre-nasm-ref/si5.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..1fda832b182dd5e919e04a014c6630f0ffb9d287 --- /dev/null +++ b/test/pre-nasm-ref/si5.pre-nasm @@ -0,0 +1,40 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @7, 1 ;JumpIfEqual 1 + cmp @7, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + mov @9, 1 ;JumpIfEqual 1 + cmp @9, 0 ;on passe par un registre temporaire + je l3 ;JumpIfEqual 2 + mov eax, 1 ;Write 1 + call iprintLF ;Write 2 +l3 : mov eax, 1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/sub1.pre-nasm b/test/pre-nasm-ref/sub1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..450082532dd19fa708c3105ce0faac6978f0035b --- /dev/null +++ b/test/pre-nasm-ref/sub1.pre-nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 10 + sub @1, 5 + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/sub2.pre-nasm b/test/pre-nasm-ref/sub2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..4a4dd72cc385f2ca13fd72b59f4898b7d644fc0e --- /dev/null +++ b/test/pre-nasm-ref/sub2.pre-nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 7 + sub @1, 20 + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/sub3.pre-nasm b/test/pre-nasm-ref/sub3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..3d2edcbdf79f63398e00047bf18970715834898d --- /dev/null +++ b/test/pre-nasm-ref/sub3.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @1, 2 + sub @1, 1 + mov @2, @1 + sub @2, 1 + mov eax, @2 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/tab1.pre-nasm b/test/pre-nasm-ref/tab1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..d43656949862e9bf07990cf4e33bfd1fbfcaf850 --- /dev/null +++ b/test/pre-nasm-ref/tab1.pre-nasm @@ -0,0 +1,50 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 12 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @7, 0 + imul @7, 4 + mov dword [tab+@7], 0 ;Affect + mov @8, 1 + imul @8, 4 + mov dword [tab+@8], 1 ;Affect + mov @9, 2 + imul @9, 4 + mov dword [tab+@9], 2 ;Affect + mov @11, 0 + imul @11, 4 + mov eax, dword [tab+@11] ;Write 1 + call iprintLF ;Write 2 + mov @13, 1 + imul @13, 4 + mov eax, dword [tab+@13] ;Write 1 + call iprintLF ;Write 2 + mov @15, 2 + imul @15, 4 + mov eax, dword [tab+@15] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/tab2.pre-nasm b/test/pre-nasm-ref/tab2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..cd9d7e35d13eef4ef7abd4861af0ea87106e684c --- /dev/null +++ b/test/pre-nasm-ref/tab2.pre-nasm @@ -0,0 +1,57 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 20 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 2 ;Affect + mov @1, dword [ebp-4] + add @1, 0 + mov @10, @1 + imul @10, 4 + mov dword [tab+@10], 34 ;Affect + mov @2, dword [ebp-4] + add @2, 1 + mov @11, @2 + imul @11, 4 + mov dword [tab+@11], 74 ;Affect + mov @3, dword [ebp-4] + add @3, 2 + mov @12, @3 + imul @12, 4 + mov dword [tab+@12], 16 ;Affect + mov @14, 2 + imul @14, 4 + mov eax, dword [tab+@14] ;Write 1 + call iprintLF ;Write 2 + mov @16, 3 + imul @16, 4 + mov eax, dword [tab+@16] ;Write 1 + call iprintLF ;Write 2 + mov @18, 4 + imul @18, 4 + mov eax, dword [tab+@18] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/tab3.pre-nasm b/test/pre-nasm-ref/tab3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..f285d1a80d2c9fd7dc117d7ae6726a8c844c4ef6 --- /dev/null +++ b/test/pre-nasm-ref/tab3.pre-nasm @@ -0,0 +1,60 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 20 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 2 ;Affect + mov dword [ebp-8], 0 ;Affect + mov @1, dword [ebp-4] + add @1, dword [ebp-8] + mov @10, @1 + imul @10, 4 + mov dword [tab+@10], 34 ;Affect + mov dword [ebp-8], 1 ;Affect + mov @2, dword [ebp-4] + add @2, dword [ebp-8] + mov @11, @2 + imul @11, 4 + mov dword [tab+@11], 74 ;Affect + mov dword [ebp-8], 2 ;Affect + mov @3, dword [ebp-4] + add @3, dword [ebp-8] + mov @12, @3 + imul @12, 4 + mov dword [tab+@12], 16 ;Affect + mov @14, 2 + imul @14, 4 + mov eax, dword [tab+@14] ;Write 1 + call iprintLF ;Write 2 + mov @16, 3 + imul @16, 4 + mov eax, dword [tab+@16] ;Write 1 + call iprintLF ;Write 2 + mov @18, 4 + imul @18, 4 + mov eax, dword [tab+@18] ;Write 1 + call iprintLF ;Write 2 + add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/tab4.pre-nasm b/test/pre-nasm-ref/tab4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..19f610c2a0c84dbcc95f83ae92eaec73baf1f490 --- /dev/null +++ b/test/pre-nasm-ref/tab4.pre-nasm @@ -0,0 +1,56 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 12 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @8, 0 + imul @8, 4 + mov dword [tab+@8], 1 ;Affect + mov @10, 0 + imul @10, 4 + mov @9, dword [tab+@10] + imul @9, 4 + mov dword [tab+@9], 12 ;Affect + mov @11, 0 + imul @11, 4 + mov @1, dword [tab+@11] + add @1, 1 + mov @12, @1 + imul @12, 4 + mov dword [tab+@12], 13 ;Affect + mov @14, 0 + imul @14, 4 + mov eax, dword [tab+@14] ;Write 1 + call iprintLF ;Write 2 + mov @16, 1 + imul @16, 4 + mov eax, dword [tab+@16] ;Write 1 + call iprintLF ;Write 2 + mov @18, 2 + imul @18, 4 + mov eax, dword [tab+@18] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/tantque1.pre-nasm b/test/pre-nasm-ref/tantque1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..fa993f893fc6cb3ac1663d68defa6b1ac252ce38 --- /dev/null +++ b/test/pre-nasm-ref/tantque1.pre-nasm @@ -0,0 +1,44 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect +l0 : mov @1, 1 ;Affect + mov @9, 0 ;JumpIfLess 1 + cmp @9, dword [ebp-4] ;on passe par un registre temporaire + jl l2 ;JumpIfLess 2 + mov @1, 0 ;Affect +l2 : cmp @1, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + mov @2, dword [ebp-4] + sub @2, 1 + mov dword [ebp-4], @2 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/tantque2.pre-nasm b/test/pre-nasm-ref/tantque2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..02a466d1eaa2d6c993af18866fd8dedb00b89634 --- /dev/null +++ b/test/pre-nasm-ref/tantque2.pre-nasm @@ -0,0 +1,54 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 0 ;Affect +l0 : mov @1, 1 ;Affect + cmp dword [ebp-4], 4 ;JumpIfLess 1 + jl l2 ;JumpIfLess 2 + mov @1, 0 ;Affect +l2 : cmp @1, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov dword [ebp-8], 0 ;Affect +l3 : mov @2, 1 ;Affect + cmp dword [ebp-8], 4 ;JumpIfLess 1 + jl l5 ;JumpIfLess 2 + mov @2, 0 ;Affect +l5 : cmp @2, 0 ;JumpIfEqual 1 + je l4 ;JumpIfEqual 2 + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp-8] ;Write 1 + call iprintLF ;Write 2 + mov @3, dword [ebp-8] + add @3, 1 + mov dword [ebp-8], @3 ;Affect + jmp l3 ;Jump +l4 : mov @4, dword [ebp-4] + add @4, 1 + mov dword [ebp-4], @4 ;Affect + jmp l0 ;Jump +l1 : add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/tri.pre-nasm b/test/pre-nasm-ref/tri.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..382fef787c9d3964b737375294a5561ee757f004 --- /dev/null +++ b/test/pre-nasm-ref/tri.pre-nasm @@ -0,0 +1,214 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +tab : resd 40 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +initialiser : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov @22, 0 + imul @22, 4 + mov dword [tab+@22], 8 ;Affect + mov @23, 1 + imul @23, 4 + mov dword [tab+@23], 6 ;Affect + mov @24, 2 + imul @24, 4 + mov dword [tab+@24], 9 ;Affect + mov @25, 3 + imul @25, 4 + mov dword [tab+@25], 9 ;Affect + mov @26, 4 + imul @26, 4 + mov dword [tab+@26], 4 ;Affect + mov @27, 5 + imul @27, 4 + mov dword [tab+@27], 2 ;Affect + mov @28, 6 + imul @28, 4 + mov dword [tab+@28], 3 ;Affect + mov @29, 7 + imul @29, 4 + mov dword [tab+@29], 1 ;Affect + mov @30, 8 + imul @30, 4 + mov dword [tab+@30], 4 ;Affect + mov @31, 9 + imul @31, 4 + mov dword [tab+@31], 5 ;Affect + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +afficher : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 0 ;Affect +l0 : mov @1, 1 ;Affect + mov @40, dword [ebp-4] ;JumpIfLess 1 + cmp @40, dword [ebp+12] ;on passe par un registre temporaire + jl l2 ;JumpIfLess 2 + mov @1, 0 ;Affect +l2 : cmp @1, 0 ;JumpIfEqual 1 + je l1 ;JumpIfEqual 2 + mov @42, dword [ebp-4] + imul @42, 4 + mov eax, dword [tab+@42] ;Write 1 + call iprintLF ;Write 2 + mov @2, dword [ebp-4] + add @2, 1 + mov dword [ebp-4], @2 ;Affect + jmp l0 ;Jump +l1 : mov eax, 0 ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +echanger : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov @52, dword [ebp+12] + imul @52, 4 + mov @53, dword [tab+@52] ;Affect + mov dword [ebp-4], @53 ;on passe par un registre temporaire + mov @54, dword [ebp+16] + imul @54, 4 + mov @55, dword [ebp+12] + imul @55, 4 + mov @56, dword [tab+@54] ;Affect + mov dword [tab+@55], @56 ;on passe par un registre temporaire + mov @57, dword [ebp+16] + imul @57, 4 + mov @58, dword [ebp-4] ;Affect + mov dword [tab+@57], @58 ;on passe par un registre temporaire + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +trier : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 12 ;allocation des variables locales + mov @67, dword [ebp+12] ;Affect + mov dword [ebp-12], @67 ;on passe par un registre temporaire + mov dword [ebp-4], 1 ;Affect +l3 : mov @3, 1 ;Affect + cmp dword [ebp-4], 1 ;JumpIfEqual 1 + je l5 ;JumpIfEqual 2 + mov @3, 0 ;Affect +l5 : cmp @3, 0 ;JumpIfEqual 1 + je l4 ;JumpIfEqual 2 + mov dword [ebp-4], 0 ;Affect + mov dword [ebp-8], 0 ;Affect +l6 : mov @5, dword [ebp-12] + sub @5, 1 + mov @4, 1 ;Affect + cmp dword [ebp-8], @5 ;JumpIfLess 1 + jl l8 ;JumpIfLess 2 + mov @4, 0 ;Affect +l8 : cmp @4, 0 ;JumpIfEqual 1 + je l7 ;JumpIfEqual 2 + mov @7, dword [ebp-8] + add @7, 1 + mov @6, 1 ;Affect + mov @68, @7 + imul @68, 4 + mov @69, dword [ebp-8] + imul @69, 4 + mov @70, dword [tab+@68] ;JumpIfLess 1 + cmp @70, dword [tab+@69] ;on passe par un registre temporaire + jl l11 ;JumpIfLess 2 + mov @6, 0 ;Affect +l11 : cmp @6, 0 ;JumpIfEqual 1 + je l10 ;JumpIfEqual 2 + push dword [ebp-8] ;Param + mov @9, dword [ebp-8] + add @9, 1 + push @9 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call echanger + pop @8 ;récupération de la valeur de retour + add esp, 8 ;désallocation des arguments + mov dword [ebp-4], 1 ;Affect +l10 : mov @10, dword [ebp-8] + add @10, 1 + mov dword [ebp-8], @10 ;Affect + jmp l6 ;Jump +l7 : mov @11, dword [ebp-12] + sub @11, 1 + mov dword [ebp-12], @11 ;Affect + jmp l3 ;Jump +l4 : add esp, 12 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + sub esp, 4 ;allocation mémoire pour la valeur de retour + call initialiser + pop @12 ;récupération de la valeur de retour + push 10 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call afficher + pop @13 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + push 10 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call trier + pop @14 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + push 10 ;Param + sub esp, 4 ;allocation mémoire pour la valeur de retour + call afficher + pop @15 ;récupération de la valeur de retour + add esp, 4 ;désallocation des arguments + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varglob1.pre-nasm b/test/pre-nasm-ref/varglob1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..99d5927ee499b346e4134460ca6f6ea467f3289a --- /dev/null +++ b/test/pre-nasm-ref/varglob1.pre-nasm @@ -0,0 +1,32 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +variable : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [variable], 6834 ;Affect + mov eax, dword [variable] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varglob2.pre-nasm b/test/pre-nasm-ref/varglob2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..a4e84c3f93cebf257dc71c9b2a7e8444935d1c4c --- /dev/null +++ b/test/pre-nasm-ref/varglob2.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +variable : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [variable], 10 ;Affect + mov @1, dword [variable] + add @1, 50 + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varglob3.pre-nasm b/test/pre-nasm-ref/varglob3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..8523503287bffbb378532cb427d89138356ffa0c --- /dev/null +++ b/test/pre-nasm-ref/varglob3.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +var2 : resd 4 ;variable globale +var1 : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [var1], 10 ;Affect + mov dword [var2], 34 ;Affect + mov eax, dword [var1] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [var2] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varglob4.pre-nasm b/test/pre-nasm-ref/varglob4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..8ca2926899c4c8891fa881b9952c214323cb35c6 --- /dev/null +++ b/test/pre-nasm-ref/varglob4.pre-nasm @@ -0,0 +1,36 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +var2 : resd 4 ;variable globale +var1 : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [var1], 10 ;Affect + mov dword [var2], 34 ;Affect + mov @1, dword [var1] + add @1, dword [var2] + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varloc1.pre-nasm b/test/pre-nasm-ref/varloc1.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..2b2479ef1ef840364e54834d4f9fcf6e61a1c646 --- /dev/null +++ b/test/pre-nasm-ref/varloc1.pre-nasm @@ -0,0 +1,31 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 6834 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varloc2.pre-nasm b/test/pre-nasm-ref/varloc2.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..8c40b7483b72a6abe237f84baa7a6752983ed421 --- /dev/null +++ b/test/pre-nasm-ref/varloc2.pre-nasm @@ -0,0 +1,33 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov @1, dword [ebp-4] + add @1, 50 + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varloc3.pre-nasm b/test/pre-nasm-ref/varloc3.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..bd7329d3af5b9d55c4448862e1aab5f6e2ddac60 --- /dev/null +++ b/test/pre-nasm-ref/varloc3.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov dword [ebp-8], 30 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + mov eax, dword [ebp-8] ;Write 1 + call iprintLF ;Write 2 + add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varloc4.pre-nasm b/test/pre-nasm-ref/varloc4.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..01d032c019e8e41a056c0f86b9ead53f0e1c6707 --- /dev/null +++ b/test/pre-nasm-ref/varloc4.pre-nasm @@ -0,0 +1,34 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 8 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov dword [ebp-8], 30 ;Affect + mov @1, dword [ebp-4] + add @1, dword [ebp-8] + mov eax, @1 ;Write 1 + call iprintLF ;Write 2 + add esp, 8 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/pre-nasm-ref/varloc5.pre-nasm b/test/pre-nasm-ref/varloc5.pre-nasm new file mode 100644 index 0000000000000000000000000000000000000000..613c517bedc2545988823f6d7cdd901c3833d577 --- /dev/null +++ b/test/pre-nasm-ref/varloc5.pre-nasm @@ -0,0 +1,52 @@ +%include 'io.asm' + +section .bss +sinput : resb 255 ;reserve a 255 byte space in memory for the users input string +var1 : resd 4 ;variable globale + +section .text +global _start +_start: + sub esp, 4 ;allocation mémoire pour la valeur de retour + call main + pop @0 ;récupération de la valeur de retour + mov ebx, 0 ; valeur de retour du programme + mov eax, 1 ; code de sortie + int 0x80 +f : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 4 ;allocation des variables locales + mov dword [ebp-4], 10 ;Affect + mov eax, dword [ebp-4] ;Write 1 + call iprintLF ;Write 2 + add esp, 4 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret +main : push ebp ;sauvegarde la valeur de ebp + mov ebp, esp ;nouvelle valeur de ebp + push eax ;sauvegarde de eax + push ebx ;sauvegarde de ebx + push ecx ;sauvegarde de ecx + push edx ;sauvegarde de edx + sub esp, 0 ;allocation des variables locales + mov dword [var1], 20 ;Affect + sub esp, 4 ;allocation mémoire pour la valeur de retour + call f + pop @1 ;récupération de la valeur de retour + mov eax, dword [var1] ;Write 1 + call iprintLF ;Write 2 + add esp, 0 ;désallocation des variables locales + pop edx ;restaure edx + pop ecx ;restaure ecx + pop ebx ;restaure ebx + pop eax ;restaure eax + pop ebp ;restaure la valeur de ebp + ret diff --git a/test/sa-ref/add1.sa b/test/sa-ref/add1.sa new file mode 100644 index 0000000000000000000000000000000000000000..5d44ab11b03a062bf0134603fbbb0c6f35ab5c64 --- /dev/null +++ b/test/sa-ref/add1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd 3 10)) null))) null)) diff --git a/test/sa-ref/add2.sa b/test/sa-ref/add2.sa new file mode 100644 index 0000000000000000000000000000000000000000..1eaaf82fdcb6c0d4fa12b8befaab428a9915f2eb --- /dev/null +++ b/test/sa-ref/add2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd (SaExpAdd 2 4) 8)) null))) null)) diff --git a/test/sa-ref/affect1.sa b/test/sa-ref/affect1.sa new file mode 100644 index 0000000000000000000000000000000000000000..f1ab7208f592c7b47ea9534dd53e3122e90cae15 --- /dev/null +++ b/test/sa-ref/affect1.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecVarSimple a entier) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 1) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null)))) null)) diff --git a/test/sa-ref/affect2.sa b/test/sa-ref/affect2.sa new file mode 100644 index 0000000000000000000000000000000000000000..c385bfe89cd45f054cd9c70164097f757e8c12ee --- /dev/null +++ b/test/sa-ref/affect2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 1) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null)))) null)) diff --git a/test/sa-ref/affect3.sa b/test/sa-ref/affect3.sa new file mode 100644 index 0000000000000000000000000000000000000000..8a9fc32b66bd46039e3535562f68e7038e4daa41 --- /dev/null +++ b/test/sa-ref/affect3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 1) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null)))) (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) null) (SaInstBloc (SaLInst (SaAppel f (SaLExp 3 null)) null))) null))) diff --git a/test/sa-ref/and1.sa b/test/sa-ref/and1.sa new file mode 100644 index 0000000000000000000000000000000000000000..441514f4e1150542e72fc192c919f438b3dc9d2e --- /dev/null +++ b/test/sa-ref/and1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd vrai vrai)) null))) null)) diff --git a/test/sa-ref/and2.sa b/test/sa-ref/and2.sa new file mode 100644 index 0000000000000000000000000000000000000000..b973e3f11a92d12fbf11f5f38277c8bcd34f0de9 --- /dev/null +++ b/test/sa-ref/and2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd vrai faux)) null))) null)) diff --git a/test/sa-ref/and3.sa b/test/sa-ref/and3.sa new file mode 100644 index 0000000000000000000000000000000000000000..64e377e1160d9532d23add2134eb8662f49c1970 --- /dev/null +++ b/test/sa-ref/and3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd faux vrai)) null))) null)) diff --git a/test/sa-ref/and4.sa b/test/sa-ref/and4.sa new file mode 100644 index 0000000000000000000000000000000000000000..af3a8c1d5ce613ecccd23f6ba99f0b775c5b3002 --- /dev/null +++ b/test/sa-ref/and4.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd faux faux)) null))) null)) diff --git a/test/sa-ref/and5.sa b/test/sa-ref/and5.sa new file mode 100644 index 0000000000000000000000000000000000000000..67fbb823330032d3e8cd89411ffdc329b0267339 --- /dev/null +++ b/test/sa-ref/and5.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd (SaExpAnd vrai faux) vrai)) null))) null)) diff --git a/test/sa-ref/appel-param1.sa b/test/sa-ref/appel-param1.sa new file mode 100644 index 0000000000000000000000000000000000000000..f8f48cd884cbe2311d72fca6d1d9b7bb8c83b625 --- /dev/null +++ b/test/sa-ref/appel-param1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f (SaLExp 1 null)) null))) null))) diff --git a/test/sa-ref/appel-param2.sa b/test/sa-ref/appel-param2.sa new file mode 100644 index 0000000000000000000000000000000000000000..f39770f04095f69d29ee6bb57a03cf2ac64a400d --- /dev/null +++ b/test/sa-ref/appel-param2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) (SaLDecVar (SaDecVarSimple b entier) null)) null (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple b))) null)))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f (SaLExp 1 (SaLExp 456 null))) null))) null))) diff --git a/test/sa-ref/appel-param3.sa b/test/sa-ref/appel-param3.sa new file mode 100644 index 0000000000000000000000000000000000000000..d022a660831ee0d6a5fc29fb3dab2362c07d1d49 --- /dev/null +++ b/test/sa-ref/appel-param3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc f nul (SaLDecVar (SaDecVarSimple a entier) (SaLDecVar (SaDecVarSimple b entier) (SaLDecVar (SaDecVarSimple c entier) (SaLDecVar (SaDecVarSimple d entier) (SaLDecVar (SaDecVarSimple e entier) null))))) null (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple b))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple c))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple d))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple e))) null))))))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f (SaLExp 1 (SaLExp 2 (SaLExp 3 (SaLExp 4 (SaLExp 5 null)))))) null))) null))) diff --git a/test/sa-ref/appel-retour1.sa b/test/sa-ref/appel-retour1.sa new file mode 100644 index 0000000000000000000000000000000000000000..7bb6f84b0cc95392702d6926853b193c52850908 --- /dev/null +++ b/test/sa-ref/appel-retour1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc f entier (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstRetour (SaExpVar (SaVarSimple a))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAppel (SaAppel f (SaLExp 3712 null)))) null))) null))) diff --git a/test/sa-ref/appel1.sa b/test/sa-ref/appel1.sa new file mode 100644 index 0000000000000000000000000000000000000000..6de41b4ac5ca235a860b690958363f270c388a0d --- /dev/null +++ b/test/sa-ref/appel1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc f nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f null) null))) null))) diff --git a/test/sa-ref/appel2.sa b/test/sa-ref/appel2.sa new file mode 100644 index 0000000000000000000000000000000000000000..891435b8db7dad99448c4ade7cf3b012bf327917 --- /dev/null +++ b/test/sa-ref/appel2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc g nul null null (SaInstBloc (SaLInst (SaInstEcriture 2) null))) (SaLDecFonc (SaDecFonc f nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) (SaLInst (SaAppel g null) null)))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f null) null))) null)))) diff --git a/test/sa-ref/appel3.sa b/test/sa-ref/appel3.sa new file mode 100644 index 0000000000000000000000000000000000000000..63ad386965f745e2a0584683b96341610a683330 --- /dev/null +++ b/test/sa-ref/appel3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc g nul null null (SaInstBloc (SaLInst (SaInstEcriture 2) null))) (SaLDecFonc (SaDecFonc f nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel f null) (SaLInst (SaAppel g null) null)))) null)))) diff --git a/test/sa-ref/div1.sa b/test/sa-ref/div1.sa new file mode 100644 index 0000000000000000000000000000000000000000..c6889353bd72d014dfeec455910cee85a296de3a --- /dev/null +++ b/test/sa-ref/div1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv 4 2)) null))) null)) diff --git a/test/sa-ref/div2.sa b/test/sa-ref/div2.sa new file mode 100644 index 0000000000000000000000000000000000000000..d50316670264ff5f39d39f243cafee0593aa6b29 --- /dev/null +++ b/test/sa-ref/div2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv 0 712)) null))) null)) diff --git a/test/sa-ref/div3.sa b/test/sa-ref/div3.sa new file mode 100644 index 0000000000000000000000000000000000000000..a2c6e4c31a4c5b2afe5fcb1e01bf4620309f4472 --- /dev/null +++ b/test/sa-ref/div3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv (SaExpDiv 4 2) 2)) null))) null)) diff --git a/test/sa-ref/div4.sa b/test/sa-ref/div4.sa new file mode 100644 index 0000000000000000000000000000000000000000..08acfe919c01e010c234d4f2b9a99982558ec1fd --- /dev/null +++ b/test/sa-ref/div4.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpDiv 2 3)) null))) null)) diff --git a/test/sa-ref/ecrire1.sa b/test/sa-ref/ecrire1.sa new file mode 100644 index 0000000000000000000000000000000000000000..49def4af8fbda32f70ffb75f5c62828b23a46cf9 --- /dev/null +++ b/test/sa-ref/ecrire1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 3456) null))) null)) diff --git a/test/sa-ref/ecrire2.sa b/test/sa-ref/ecrire2.sa new file mode 100644 index 0000000000000000000000000000000000000000..1e1054c6d3d790445975a80d4f20caa9466fff04 --- /dev/null +++ b/test/sa-ref/ecrire2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 0) null))) null)) diff --git a/test/sa-ref/egal1.sa b/test/sa-ref/egal1.sa new file mode 100644 index 0000000000000000000000000000000000000000..14530786f743ce47a7394e56d4f1c43132dc17a0 --- /dev/null +++ b/test/sa-ref/egal1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual 123 123)) null))) null)) diff --git a/test/sa-ref/egal2.sa b/test/sa-ref/egal2.sa new file mode 100644 index 0000000000000000000000000000000000000000..d049f597ee94fd4878e8738e62992fd4455e6a5c --- /dev/null +++ b/test/sa-ref/egal2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual 412 34)) null))) null)) diff --git a/test/sa-ref/egal3.sa b/test/sa-ref/egal3.sa new file mode 100644 index 0000000000000000000000000000000000000000..cb1c0c48b6205e64c266e3837863ac1ebc87dd98 --- /dev/null +++ b/test/sa-ref/egal3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual (SaExpEqual 2 2) vrai)) null))) null)) diff --git a/test/sa-ref/err1.sa b/test/sa-ref/err1.sa new file mode 100644 index 0000000000000000000000000000000000000000..c79606334c992a2311ad9b0ca671f0c0e55e807d --- /dev/null +++ b/test/sa-ref/err1.sa @@ -0,0 +1,18 @@ +<SaProg> + <SaLDec> + <SaDecFonc> + <nom>main</nom> + <SaInstBloc> + <SaLInst> + <SaInstEcriture> + <SaExpVar> + <SaVarSimple> + <nom>var1</nom> + </SaVarSimple> + </SaExpVar> + </SaInstEcriture> + </SaLInst> + </SaInstBloc> + </SaDecFonc> + </SaLDec> +</SaProg> diff --git a/test/sa-ref/err2.sa b/test/sa-ref/err2.sa new file mode 100644 index 0000000000000000000000000000000000000000..4409c766f57d3c471793c2cb137a53fac501be01 --- /dev/null +++ b/test/sa-ref/err2.sa @@ -0,0 +1,13 @@ +<SaProg> + <SaLDec> + <SaDecFonc> + <nom>main</nom> + <SaInstBloc> + <SaLInst> + <SaAppel> + </SaAppel> + </SaLInst> + </SaInstBloc> + </SaDecFonc> + </SaLDec> +</SaProg> diff --git a/test/sa-ref/err3.sa b/test/sa-ref/err3.sa new file mode 100644 index 0000000000000000000000000000000000000000..5b42731bb69caed04433b75311662ee679760a3b --- /dev/null +++ b/test/sa-ref/err3.sa @@ -0,0 +1,23 @@ +<SaProg> + <SaLDec> + <SaDecFonc> + <nom>f</nom> + <SaLDec> + <SaDecVar> + <nom>a</nom> + </SaDecVar> + </SaLDec> + </SaDecFonc> + <SaLDec> + <SaDecFonc> + <nom>main</nom> + <SaInstBloc> + <SaLInst> + <SaAppel> + </SaAppel> + </SaLInst> + </SaInstBloc> + </SaDecFonc> + </SaLDec> + </SaLDec> +</SaProg> diff --git a/test/sa-ref/err4.sa b/test/sa-ref/err4.sa new file mode 100644 index 0000000000000000000000000000000000000000..2044b50bcccb4a17930f9c06cec242eb4f051cf7 --- /dev/null +++ b/test/sa-ref/err4.sa @@ -0,0 +1,33 @@ +<SaProg> + <SaLDec> + <SaDecFonc> + <nom>f</nom> + <SaLDec> + <SaDecVar> + <nom>a</nom> + </SaDecVar> + </SaLDec> + <SaLDec> + <SaDecVar> + <nom>a</nom> + </SaDecVar> + </SaLDec> + </SaDecFonc> + <SaLDec> + <SaDecFonc> + <nom>main</nom> + <SaInstBloc> + <SaLInst> + <SaAppel> + <SaLExp> + <SaExpInt> + <val>1</val> + </SaExpInt> + </SaLExp> + </SaAppel> + </SaLInst> + </SaInstBloc> + </SaDecFonc> + </SaLDec> + </SaLDec> +</SaProg> diff --git a/test/sa-ref/err5.sa b/test/sa-ref/err5.sa new file mode 100644 index 0000000000000000000000000000000000000000..f8226c89e651412482da82f23da12b000105b81f --- /dev/null +++ b/test/sa-ref/err5.sa @@ -0,0 +1,39 @@ +<SaProg> + <SaLDec> + <SaDecFonc> + <nom>f</nom> + <SaInstBloc> + <SaLInst> + <SaInstEcriture> + <SaExpInt> + <val>1</val> + </SaExpInt> + </SaInstEcriture> + </SaLInst> + </SaInstBloc> + </SaDecFonc> + <SaLDec> + <SaDecFonc> + <nom>main</nom> + <SaLDec> + <SaDecVar> + <nom>f</nom> + </SaDecVar> + </SaLDec> + <SaInstBloc> + <SaLInst> + <SaInstAffect> + <SaVarSimple> + <nom>f</nom> + </SaVarSimple> + <SaExpAppel> + <SaAppel> + </SaAppel> + </SaExpAppel> + </SaInstAffect> + </SaLInst> + </SaInstBloc> + </SaDecFonc> + </SaLDec> + </SaLDec> +</SaProg> diff --git a/test/sa-ref/fibo.sa b/test/sa-ref/fibo.sa new file mode 100644 index 0000000000000000000000000000000000000000..407ebdef6012000c38432bb735959ffea8990f7a --- /dev/null +++ b/test/sa-ref/fibo.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc fibo entier (SaLDecVar (SaDecVarSimple n entier) null) null (SaInstBloc (SaLInst (SaInstSi (SaExpInf (SaExpVar (SaVarSimple n)) 2) (SaInstBloc (SaLInst (SaInstRetour 1) null)) (SaInstBloc (SaLInst (SaInstRetour (SaExpAdd (SaExpAppel (SaAppel fibo (SaLExp (SaExpSub (SaExpVar (SaVarSimple n)) 1) null))) (SaExpAppel (SaAppel fibo (SaLExp (SaExpSub (SaExpVar (SaVarSimple n)) 2) null))))) null))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAppel (SaAppel fibo (SaLExp 9 null)))) null))) null))) diff --git a/test/sa-ref/inf1.sa b/test/sa-ref/inf1.sa new file mode 100644 index 0000000000000000000000000000000000000000..f5a5868546c9f4141df441433d0d1a2d661f4f99 --- /dev/null +++ b/test/sa-ref/inf1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 3 3)) null))) null)) diff --git a/test/sa-ref/inf2.sa b/test/sa-ref/inf2.sa new file mode 100644 index 0000000000000000000000000000000000000000..c66c6659c3e1ee7ef7f89d79687130f29247ef07 --- /dev/null +++ b/test/sa-ref/inf2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 4 1)) null))) null)) diff --git a/test/sa-ref/inf3.sa b/test/sa-ref/inf3.sa new file mode 100644 index 0000000000000000000000000000000000000000..30eb35c37a7e93c13cec9eed78bcc6418d98f94b --- /dev/null +++ b/test/sa-ref/inf3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 312 475)) null))) null)) diff --git a/test/sa-ref/inf4.sa b/test/sa-ref/inf4.sa new file mode 100644 index 0000000000000000000000000000000000000000..58c322dd28d8ecdba85879bdace80d4c21f4275d --- /dev/null +++ b/test/sa-ref/inf4.sa @@ -0,0 +1,19 @@ +<programme type="SaProg"> + <fonctions type="SaLDec"> + <tete type="SaDecFonc" nom="main"> + <corps type="SaInstBloc"> + <val type="SaLInst"> + <tete type="SaInstEcriture"> + <arg type="SaExpInf"> + <op1 type="SaExpInf"> + <op1 type="SaExpInt" val="3"/> + <op2 type="SaExpInt" val="2"/> + </op1> + <op2 type="SaExpInt" val="1"/> + </arg> + </tete> + </val> + </corps> + </tete> + </fonctions> +</programme> diff --git a/test/sa-ref/mult1.sa b/test/sa-ref/mult1.sa new file mode 100644 index 0000000000000000000000000000000000000000..d743995e203128b9c7ac7f1ae1e43eb238a870ea --- /dev/null +++ b/test/sa-ref/mult1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpMult 2 3)) null))) null)) diff --git a/test/sa-ref/mult2.sa b/test/sa-ref/mult2.sa new file mode 100644 index 0000000000000000000000000000000000000000..695c66c2c0f9fa633d86fa0a14fe2954b3bd7cde --- /dev/null +++ b/test/sa-ref/mult2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpMult 0 321)) null))) null)) diff --git a/test/sa-ref/mult3.sa b/test/sa-ref/mult3.sa new file mode 100644 index 0000000000000000000000000000000000000000..012c0a65b5e8ca62b4ea91523cdbd02a170ad0a8 --- /dev/null +++ b/test/sa-ref/mult3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpMult (SaExpMult 3 3) 2)) null))) null)) diff --git a/test/sa-ref/not1.sa b/test/sa-ref/not1.sa new file mode 100644 index 0000000000000000000000000000000000000000..2f6a8a21ea11c6e636638bd1398ee4978885f550 --- /dev/null +++ b/test/sa-ref/not1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpNot vrai)) null))) null)) diff --git a/test/sa-ref/not2.sa b/test/sa-ref/not2.sa new file mode 100644 index 0000000000000000000000000000000000000000..d955f616d7ecbe0fa392fc51eb1fe26e30402347 --- /dev/null +++ b/test/sa-ref/not2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpNot faux)) null))) null)) diff --git a/test/sa-ref/not3.sa b/test/sa-ref/not3.sa new file mode 100644 index 0000000000000000000000000000000000000000..1c04c2aaacf98dd09597852a88f0e8394b830890 --- /dev/null +++ b/test/sa-ref/not3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpNot (SaExpNot faux))) null))) null)) diff --git a/test/sa-ref/or1.sa b/test/sa-ref/or1.sa new file mode 100644 index 0000000000000000000000000000000000000000..fb4fe3c00dfe07dcf1773af4a7470c9d21a55a7c --- /dev/null +++ b/test/sa-ref/or1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai vrai)) null))) null)) diff --git a/test/sa-ref/or2.sa b/test/sa-ref/or2.sa new file mode 100644 index 0000000000000000000000000000000000000000..02cc96cb9b932acfb9cfc5d2a127d2130b2876d2 --- /dev/null +++ b/test/sa-ref/or2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai faux)) null))) null)) diff --git a/test/sa-ref/or3.sa b/test/sa-ref/or3.sa new file mode 100644 index 0000000000000000000000000000000000000000..a023eef9378764078df09ed090b0561b80f58f08 --- /dev/null +++ b/test/sa-ref/or3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr faux vrai)) null))) null)) diff --git a/test/sa-ref/or4.sa b/test/sa-ref/or4.sa new file mode 100644 index 0000000000000000000000000000000000000000..1b585b46e7dfc3aa76f91667116f54dc0774880f --- /dev/null +++ b/test/sa-ref/or4.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr faux faux)) null))) null)) diff --git a/test/sa-ref/or5.sa b/test/sa-ref/or5.sa new file mode 100644 index 0000000000000000000000000000000000000000..c0030a3310d3cad83c4a36c9b7a4c1fdbe8bfc8a --- /dev/null +++ b/test/sa-ref/or5.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr (SaExpOr faux vrai) faux)) null))) null)) diff --git a/test/sa-ref/parenth1.sa b/test/sa-ref/parenth1.sa new file mode 100644 index 0000000000000000000000000000000000000000..fba5b651e63e6ae656279999ed27bd6d6fb7a523 --- /dev/null +++ b/test/sa-ref/parenth1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 1) null))) null)) diff --git a/test/sa-ref/parenth2.sa b/test/sa-ref/parenth2.sa new file mode 100644 index 0000000000000000000000000000000000000000..ddf44a1b134f76e0cc2079919ba5a91cccae5a4f --- /dev/null +++ b/test/sa-ref/parenth2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture 2) null))) null)) diff --git a/test/sa-ref/prio23-1.sa b/test/sa-ref/prio23-1.sa new file mode 100644 index 0000000000000000000000000000000000000000..4a35127cc33fb22e7adc34f3ff762bcd2d3e53b5 --- /dev/null +++ b/test/sa-ref/prio23-1.sa @@ -0,0 +1,18 @@ +<programme type="SaProg"> + <fonctions type="SaLDec"> + <tete type="SaDecFonc" nom="main"> + <corps type="SaInstBloc"> + <val type="SaLInst"> + <tete type="SaInstEcriture"> + <arg type="SaExpMult"> + <op1 type="SaExpNot"> + <op1 type="SaExpInt" val="0"/> + </op1> + <op2 type="SaExpInt" val="10"/> + </arg> + </tete> + </val> + </corps> + </tete> + </fonctions> +</programme> diff --git a/test/sa-ref/prio23-2.sa b/test/sa-ref/prio23-2.sa new file mode 100644 index 0000000000000000000000000000000000000000..31f61f2934fd97384fee5c55354ca5f8ff49df16 --- /dev/null +++ b/test/sa-ref/prio23-2.sa @@ -0,0 +1,18 @@ +<programme type="SaProg"> + <fonctions type="SaLDec"> + <tete type="SaDecFonc" nom="main"> + <corps type="SaInstBloc"> + <val type="SaLInst"> + <tete type="SaInstEcriture"> + <arg type="SaExpMult"> + <op1 type="SaExpInt" val="3"/> + <op2 type="SaExpNot"> + <op1 type="SaExpInt" val="10"/> + </op2> + </arg> + </tete> + </val> + </corps> + </tete> + </fonctions> +</programme> diff --git a/test/sa-ref/prio23-3.sa b/test/sa-ref/prio23-3.sa new file mode 100644 index 0000000000000000000000000000000000000000..b5c61582dadd231a632c7f5959f3b841268b8487 --- /dev/null +++ b/test/sa-ref/prio23-3.sa @@ -0,0 +1,18 @@ +<programme type="SaProg"> + <fonctions type="SaLDec"> + <tete type="SaDecFonc" nom="main"> + <corps type="SaInstBloc"> + <val type="SaLInst"> + <tete type="SaInstEcriture"> + <arg type="SaExpDiv"> + <op1 type="SaExpNot"> + <op1 type="SaExpInt" val="0"/> + </op1> + <op2 type="SaExpInt" val="1"/> + </arg> + </tete> + </val> + </corps> + </tete> + </fonctions> +</programme> diff --git a/test/sa-ref/prio23-4.sa b/test/sa-ref/prio23-4.sa new file mode 100644 index 0000000000000000000000000000000000000000..05c8c94a0597937ae2370581831178b15ed58e5e --- /dev/null +++ b/test/sa-ref/prio23-4.sa @@ -0,0 +1,20 @@ +<programme type="SaProg"> + <fonctions type="SaLDec"> + <tete type="SaDecFonc" nom="main"> + <corps type="SaInstBloc"> + <val type="SaLInst"> + <tete type="SaInstEcriture"> + <arg type="SaExpDiv"> + <op1 type="SaExpNot"> + <op1 type="SaExpInt" val="1"/> + </op1> + <op2 type="SaExpNot"> + <op1 type="SaExpInt" val="0"/> + </op2> + </arg> + </tete> + </val> + </corps> + </tete> + </fonctions> +</programme> diff --git a/test/sa-ref/prio34-1.sa b/test/sa-ref/prio34-1.sa new file mode 100644 index 0000000000000000000000000000000000000000..14486aef8ccd5e4c5a75eff8f4aae1bc40474167 --- /dev/null +++ b/test/sa-ref/prio34-1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd 2 (SaExpMult 3 4))) null))) null)) diff --git a/test/sa-ref/prio34-2.sa b/test/sa-ref/prio34-2.sa new file mode 100644 index 0000000000000000000000000000000000000000..4391e90f4e338a3bd64d9d2c7214087a863b19c7 --- /dev/null +++ b/test/sa-ref/prio34-2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub (SaExpMult 2 3) 4)) null))) null)) diff --git a/test/sa-ref/prio34-3.sa b/test/sa-ref/prio34-3.sa new file mode 100644 index 0000000000000000000000000000000000000000..93274cfeb293b7d012a1fc8e82ebfeb9f647080d --- /dev/null +++ b/test/sa-ref/prio34-3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub (SaExpDiv 6 3) 72)) null))) null)) diff --git a/test/sa-ref/prio34-4.sa b/test/sa-ref/prio34-4.sa new file mode 100644 index 0000000000000000000000000000000000000000..d0d61d75758c3e730253bc4786bcebf812237106 --- /dev/null +++ b/test/sa-ref/prio34-4.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAdd 6 (SaExpDiv 20 10))) null))) null)) diff --git a/test/sa-ref/prio45-1.sa b/test/sa-ref/prio45-1.sa new file mode 100644 index 0000000000000000000000000000000000000000..74404e6426008aa4600f2446489038b42b8c76fd --- /dev/null +++ b/test/sa-ref/prio45-1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual 2 (SaExpAdd 0 1))) null))) null)) diff --git a/test/sa-ref/prio45-2.sa b/test/sa-ref/prio45-2.sa new file mode 100644 index 0000000000000000000000000000000000000000..7225d278f316adacf6a60f4018e7e1871a23ee06 --- /dev/null +++ b/test/sa-ref/prio45-2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpEqual (SaExpAdd 1 234) 1)) null))) null)) diff --git a/test/sa-ref/prio45-3.sa b/test/sa-ref/prio45-3.sa new file mode 100644 index 0000000000000000000000000000000000000000..f5fb6f090952e8bb78b17943efd6719bc6bd4c60 --- /dev/null +++ b/test/sa-ref/prio45-3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf 12 (SaExpAdd 11 100))) null))) null)) diff --git a/test/sa-ref/prio45-4.sa b/test/sa-ref/prio45-4.sa new file mode 100644 index 0000000000000000000000000000000000000000..4613fe18e913a3424895173542be907ec1e303eb --- /dev/null +++ b/test/sa-ref/prio45-4.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpInf (SaExpSub 21 21) 1)) null))) null)) diff --git a/test/sa-ref/prio56-1.sa b/test/sa-ref/prio56-1.sa new file mode 100644 index 0000000000000000000000000000000000000000..2b698f43d0b112a4fd173daf76a5c4a2cef986da --- /dev/null +++ b/test/sa-ref/prio56-1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAnd (SaExpEqual 1 2) vrai)) null))) null)) diff --git a/test/sa-ref/prio56-2.sa b/test/sa-ref/prio56-2.sa new file mode 100644 index 0000000000000000000000000000000000000000..8a5cfa0e129c1fe29b2881a7025a0dd7e23e1209 --- /dev/null +++ b/test/sa-ref/prio56-2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai (SaExpEqual faux vrai))) null))) null)) diff --git a/test/sa-ref/prio67-1.sa b/test/sa-ref/prio67-1.sa new file mode 100644 index 0000000000000000000000000000000000000000..3b05c3cbfeed1fc930dbd484cc6268f7cd78b154 --- /dev/null +++ b/test/sa-ref/prio67-1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr (SaExpAnd faux vrai) vrai)) null))) null)) diff --git a/test/sa-ref/prio67-2.sa b/test/sa-ref/prio67-2.sa new file mode 100644 index 0000000000000000000000000000000000000000..0bd44357f4945c5deff0d7900b41dacf68d46a74 --- /dev/null +++ b/test/sa-ref/prio67-2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpOr vrai (SaExpAnd vrai faux))) null))) null)) diff --git a/test/sa-ref/rec1.sa b/test/sa-ref/rec1.sa new file mode 100644 index 0000000000000000000000000000000000000000..28199815d008b366f31e5308feab5036f97251e7 --- /dev/null +++ b/test/sa-ref/rec1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc f entier (SaLDecVar (SaDecVarSimple a entier) null) null (SaInstBloc (SaLInst (SaInstSi (SaExpEqual (SaExpVar (SaVarSimple a)) 1) (SaInstBloc (SaLInst (SaInstRetour 1) null)) (SaInstBloc (SaLInst (SaInstRetour (SaExpAdd 1 (SaExpAppel (SaAppel f (SaLExp (SaExpSub (SaExpVar (SaVarSimple a)) 1) null))))) null))) null))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpAppel (SaAppel f (SaLExp 100 null)))) null))) null))) diff --git a/test/sa-ref/si1.sa b/test/sa-ref/si1.sa new file mode 100644 index 0000000000000000000000000000000000000000..86d331e258487460f275fdfb7ea022fe2ee6ba4a --- /dev/null +++ b/test/sa-ref/si1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) null) null))) null)) diff --git a/test/sa-ref/si2.sa b/test/sa-ref/si2.sa new file mode 100644 index 0000000000000000000000000000000000000000..609b54f653680a93dc8ff80ef34622d2d7bdf722 --- /dev/null +++ b/test/sa-ref/si2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi faux (SaInstBloc (SaLInst (SaInstEcriture 1) null)) (SaInstBloc (SaLInst (SaInstEcriture 0) null))) null))) null)) diff --git a/test/sa-ref/si3.sa b/test/sa-ref/si3.sa new file mode 100644 index 0000000000000000000000000000000000000000..517789abfbdc1f91a95ce65329b8bac383c2d63d --- /dev/null +++ b/test/sa-ref/si3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) (SaInstBloc (SaLInst (SaInstEcriture faux) null))) (SaLInst (SaInstEcriture vrai) null)))) null)) diff --git a/test/sa-ref/si4.sa b/test/sa-ref/si4.sa new file mode 100644 index 0000000000000000000000000000000000000000..fef8d2a157e187470285db8eb9029aa1e76890da --- /dev/null +++ b/test/sa-ref/si4.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi faux (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) (SaInstBloc (SaLInst (SaInstEcriture faux) null))) (SaLInst (SaInstEcriture vrai) null)))) null)) diff --git a/test/sa-ref/si5.sa b/test/sa-ref/si5.sa new file mode 100644 index 0000000000000000000000000000000000000000..546ff2dcbcef78da6a0ed14ee9fbf923f5f41feb --- /dev/null +++ b/test/sa-ref/si5.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) (SaLInst (SaInstSi vrai (SaInstBloc (SaLInst (SaInstEcriture vrai) null)) null) null))) null) (SaLInst (SaInstEcriture vrai) null)))) null)) diff --git a/test/sa-ref/sub1.sa b/test/sa-ref/sub1.sa new file mode 100644 index 0000000000000000000000000000000000000000..d03f2223ec693f881cfdadf38b0c1d9b171e74a7 --- /dev/null +++ b/test/sa-ref/sub1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub 10 5)) null))) null)) diff --git a/test/sa-ref/sub2.sa b/test/sa-ref/sub2.sa new file mode 100644 index 0000000000000000000000000000000000000000..d1490e9d4c23c6c6043eb34250ac2f7ad249eb47 --- /dev/null +++ b/test/sa-ref/sub2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub 7 20)) null))) null)) diff --git a/test/sa-ref/sub3.sa b/test/sa-ref/sub3.sa new file mode 100644 index 0000000000000000000000000000000000000000..9f30ba46267d3eb7ea35f5f616ded8ad5563d8d6 --- /dev/null +++ b/test/sa-ref/sub3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstEcriture (SaExpSub (SaExpSub 2 1) 1)) null))) null)) diff --git a/test/sa-ref/tab1.sa b/test/sa-ref/tab1.sa new file mode 100644 index 0000000000000000000000000000000000000000..e6c5fb0dadd7d8dd900bc6fb6c7b3914b04fd3c3 --- /dev/null +++ b/test/sa-ref/tab1.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecTab tab entier 3) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarIndicee tab 0) 0) (SaLInst (SaInstAffect (SaVarIndicee tab 1) 1) (SaLInst (SaInstAffect (SaVarIndicee tab 2) 2) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 0))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) null)))))))) null)) diff --git a/test/sa-ref/tab2.sa b/test/sa-ref/tab2.sa new file mode 100644 index 0000000000000000000000000000000000000000..077061594c81a94ba5d6d26143f4a1da2b85bd54 --- /dev/null +++ b/test/sa-ref/tab2.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecTab tab entier 5) null) (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple base entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple base) 2) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) 0)) 34) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) 1)) 74) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) 2)) 16) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 3))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 4))) null))))))))) null)) diff --git a/test/sa-ref/tab3.sa b/test/sa-ref/tab3.sa new file mode 100644 index 0000000000000000000000000000000000000000..efb0fc06357b629498c28f34bd31e16e7259a2f3 --- /dev/null +++ b/test/sa-ref/tab3.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecTab tab entier 5) null) (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple base entier) (SaLDecVar (SaDecVarSimple offset entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple base) 2) (SaLInst (SaInstAffect (SaVarSimple offset) 0) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) (SaExpVar (SaVarSimple offset)))) 34) (SaLInst (SaInstAffect (SaVarSimple offset) 1) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) (SaExpVar (SaVarSimple offset)))) 74) (SaLInst (SaInstAffect (SaVarSimple offset) 2) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple base)) (SaExpVar (SaVarSimple offset)))) 16) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 3))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 4))) null)))))))))))) null)) diff --git a/test/sa-ref/tab4.sa b/test/sa-ref/tab4.sa new file mode 100644 index 0000000000000000000000000000000000000000..372b6bb81c892ea5709664d752777cf830542134 --- /dev/null +++ b/test/sa-ref/tab4.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecTab tab entier 3) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarIndicee tab 0) 1) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpVar (SaVarIndicee tab 0))) 12) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarIndicee tab 0)) 1)) 13) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 0))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab 2))) null)))))))) null)) diff --git a/test/sa-ref/tantque1.sa b/test/sa-ref/tantque1.sa new file mode 100644 index 0000000000000000000000000000000000000000..676e5f6862c70dd10f54d1945cb7bc19ed6bf83f --- /dev/null +++ b/test/sa-ref/tantque1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 10) (SaLInst (SaInstTantQue (SaExpInf 0 (SaExpVar (SaVarSimple a))) (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstAffect (SaVarSimple a) (SaExpSub (SaExpVar (SaVarSimple a)) 1)) null)))) (SaLInst (SaInstEcriture 0) null))))) null)) diff --git a/test/sa-ref/tantque2.sa b/test/sa-ref/tantque2.sa new file mode 100644 index 0000000000000000000000000000000000000000..6482da5701bebb7de0557c34c4ac34a978f57056 --- /dev/null +++ b/test/sa-ref/tantque2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple a entier) (SaLDecVar (SaDecVarSimple b entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple a) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple a)) 4) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple b) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple b)) 4) (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple a))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple b))) (SaLInst (SaInstAffect (SaVarSimple b) (SaExpAdd (SaExpVar (SaVarSimple b)) 1)) null))))) (SaLInst (SaInstAffect (SaVarSimple a) (SaExpAdd (SaExpVar (SaVarSimple a)) 1)) null))))) null)))) null)) diff --git a/test/sa-ref/tri.sa b/test/sa-ref/tri.sa new file mode 100644 index 0000000000000000000000000000000000000000..69b37534ed3ec01824d281781e3add56422fe1d2 --- /dev/null +++ b/test/sa-ref/tri.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecTab tab entier 10) null) (SaLDecFonc (SaDecFonc initialiser nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarIndicee tab 0) 8) (SaLInst (SaInstAffect (SaVarIndicee tab 1) 6) (SaLInst (SaInstAffect (SaVarIndicee tab 2) 9) (SaLInst (SaInstAffect (SaVarIndicee tab 3) 9) (SaLInst (SaInstAffect (SaVarIndicee tab 4) 4) (SaLInst (SaInstAffect (SaVarIndicee tab 5) 2) (SaLInst (SaInstAffect (SaVarIndicee tab 6) 3) (SaLInst (SaInstAffect (SaVarIndicee tab 7) 1) (SaLInst (SaInstAffect (SaVarIndicee tab 8) 4) (SaLInst (SaInstAffect (SaVarIndicee tab 9) 5) null)))))))))))) (SaLDecFonc (SaDecFonc afficher nul (SaLDecVar (SaDecVarSimple n entier) null) (SaLDecVar (SaDecVarSimple i entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple i) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple i)) (SaExpVar (SaVarSimple n))) (SaInstBloc (SaLInst (SaInstEcriture (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple i))))) (SaLInst (SaInstAffect (SaVarSimple i) (SaExpAdd (SaExpVar (SaVarSimple i)) 1)) null)))) (SaLInst (SaInstEcriture 0) null))))) (SaLDecFonc (SaDecFonc echanger nul (SaLDecVar (SaDecVarSimple i entier) (SaLDecVar (SaDecVarSimple j entier) null)) (SaLDecVar (SaDecVarSimple temp entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple temp) (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple j))))) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpVar (SaVarSimple j))) (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple i))))) (SaLInst (SaInstAffect (SaVarIndicee tab (SaExpVar (SaVarSimple i))) (SaExpVar (SaVarSimple temp))) null))))) (SaLDecFonc (SaDecFonc trier nul (SaLDecVar (SaDecVarSimple n entier) null) (SaLDecVar (SaDecVarSimple echange entier) (SaLDecVar (SaDecVarSimple j entier) (SaLDecVar (SaDecVarSimple m entier) null))) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple m) (SaExpVar (SaVarSimple n))) (SaLInst (SaInstAffect (SaVarSimple echange) 1) (SaLInst (SaInstTantQue (SaExpEqual (SaExpVar (SaVarSimple echange)) 1) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple echange) 0) (SaLInst (SaInstAffect (SaVarSimple j) 0) (SaLInst (SaInstTantQue (SaExpInf (SaExpVar (SaVarSimple j)) (SaExpSub (SaExpVar (SaVarSimple m)) 1)) (SaInstBloc (SaLInst (SaInstSi (SaExpInf (SaExpVar (SaVarIndicee tab (SaExpAdd (SaExpVar (SaVarSimple j)) 1))) (SaExpVar (SaVarIndicee tab (SaExpVar (SaVarSimple j))))) (SaInstBloc (SaLInst (SaAppel echanger (SaLExp (SaExpVar (SaVarSimple j)) (SaLExp (SaExpAdd (SaExpVar (SaVarSimple j)) 1) null))) (SaLInst (SaInstAffect (SaVarSimple echange) 1) null))) null) (SaLInst (SaInstAffect (SaVarSimple j) (SaExpAdd (SaExpVar (SaVarSimple j)) 1)) null)))) (SaLInst (SaInstAffect (SaVarSimple m) (SaExpSub (SaExpVar (SaVarSimple m)) 1)) null)))))) null))))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaAppel initialiser null) (SaLInst (SaAppel afficher (SaLExp 10 null)) (SaLInst (SaAppel trier (SaLExp 10 null)) (SaLInst (SaAppel afficher (SaLExp 10 null)) null)))))) null)))))) diff --git a/test/sa-ref/varglob1.sa b/test/sa-ref/varglob1.sa new file mode 100644 index 0000000000000000000000000000000000000000..f0e56eb12aa619553375b4ff661d6dd25c0fad12 --- /dev/null +++ b/test/sa-ref/varglob1.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecVarSimple variable entier) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 6834) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple variable))) null)))) null)) diff --git a/test/sa-ref/varglob2.sa b/test/sa-ref/varglob2.sa new file mode 100644 index 0000000000000000000000000000000000000000..5f173ad9f00cd74d6334a64ab1e11d622a5d6372 --- /dev/null +++ b/test/sa-ref/varglob2.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecVarSimple variable entier) null) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 10) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple variable)) 50)) null)))) null)) diff --git a/test/sa-ref/varglob3.sa b/test/sa-ref/varglob3.sa new file mode 100644 index 0000000000000000000000000000000000000000..846697305f7abcfa1e4e123c0f2d596b30d3d35d --- /dev/null +++ b/test/sa-ref/varglob3.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 34) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var2))) null)))))) null)) diff --git a/test/sa-ref/varglob4.sa b/test/sa-ref/varglob4.sa new file mode 100644 index 0000000000000000000000000000000000000000..4d47fed3a34fdc6be3f3fa2fc5db6284be2b8f5a --- /dev/null +++ b/test/sa-ref/varglob4.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 34) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple var1)) (SaExpVar (SaVarSimple var2)))) null))))) null)) diff --git a/test/sa-ref/varloc1.sa b/test/sa-ref/varloc1.sa new file mode 100644 index 0000000000000000000000000000000000000000..f73881af093a60fa354646b006976fa551c00242 --- /dev/null +++ b/test/sa-ref/varloc1.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple variable entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 6834) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple variable))) null)))) null)) diff --git a/test/sa-ref/varloc2.sa b/test/sa-ref/varloc2.sa new file mode 100644 index 0000000000000000000000000000000000000000..35a55ff8724bace3df9f3392254ba86b85616997 --- /dev/null +++ b/test/sa-ref/varloc2.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple variable entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple variable) 10) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple variable)) 50)) null)))) null)) diff --git a/test/sa-ref/varloc3.sa b/test/sa-ref/varloc3.sa new file mode 100644 index 0000000000000000000000000000000000000000..3c7878c76ccf675dcad3f1c5bc6202b4575f03a3 --- /dev/null +++ b/test/sa-ref/varloc3.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 30) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var2))) null)))))) null)) diff --git a/test/sa-ref/varloc4.sa b/test/sa-ref/varloc4.sa new file mode 100644 index 0000000000000000000000000000000000000000..0578507dd5968c5fe82fc524a5a407bb50feea7e --- /dev/null +++ b/test/sa-ref/varloc4.sa @@ -0,0 +1 @@ +(SaProg null (SaLDecFonc (SaDecFonc main nul null (SaLDecVar (SaDecVarSimple var1 entier) (SaLDecVar (SaDecVarSimple var2 entier) null)) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstAffect (SaVarSimple var2) 30) (SaLInst (SaInstEcriture (SaExpAdd (SaExpVar (SaVarSimple var1)) (SaExpVar (SaVarSimple var2)))) null))))) null)) diff --git a/test/sa-ref/varloc5.sa b/test/sa-ref/varloc5.sa new file mode 100644 index 0000000000000000000000000000000000000000..dbeb0be8a23167bb3b1599bdbb43d9088ee6cb55 --- /dev/null +++ b/test/sa-ref/varloc5.sa @@ -0,0 +1 @@ +(SaProg (SaLDecVar (SaDecVarSimple var1 entier) null) (SaLDecFonc (SaDecFonc f nul null (SaLDecVar (SaDecVarSimple var1 entier) null) (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 10) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) null)))) (SaLDecFonc (SaDecFonc main nul null null (SaInstBloc (SaLInst (SaInstAffect (SaVarSimple var1) 20) (SaLInst (SaAppel f null) (SaLInst (SaInstEcriture (SaExpVar (SaVarSimple var1))) null))))) null))) diff --git a/test/sc-ref/add1.sc b/test/sc-ref/add1.sc new file mode 100644 index 0000000000000000000000000000000000000000..5ba6a480a29890b70b93fd840dc04e14d361af1b --- /dev/null +++ b/test/sc-ref/add1.sc @@ -0,0 +1,44 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/add2.sc b/test/sc-ref/add2.sc new file mode 100644 index 0000000000000000000000000000000000000000..5447ac910caee351436e37efef64078847ac243e --- /dev/null +++ b/test/sc-ref/add2.sc @@ -0,0 +1,52 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/affect1.sc b/test/sc-ref/affect1.sc new file mode 100644 index 0000000000000000000000000000000000000000..919a43405a186954fd65d20f556024a803342d62 --- /dev/null +++ b/test/sc-ref/affect1.sc @@ -0,0 +1,66 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/affect2.sc b/test/sc-ref/affect2.sc new file mode 100644 index 0000000000000000000000000000000000000000..55761e9d89bd27bd62295bbd738b4e7d185f96a2 --- /dev/null +++ b/test/sc-ref/affect2.sc @@ -0,0 +1,66 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/affect3.sc b/test/sc-ref/affect3.sc new file mode 100644 index 0000000000000000000000000000000000000000..6046f37de9328f1ce4cd85e6f286d61867f772df --- /dev/null +++ b/test/sc-ref/affect3.sc @@ -0,0 +1,106 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <AAvecparamListeparam> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AAvecparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <ARecursifListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + </AFinalListeexpbis> + </ARecursifListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/and1.sc b/test/sc-ref/and1.sc new file mode 100644 index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569 --- /dev/null +++ b/test/sc-ref/and1.sc @@ -0,0 +1,48 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/and2.sc b/test/sc-ref/and2.sc new file mode 100644 index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569 --- /dev/null +++ b/test/sc-ref/and2.sc @@ -0,0 +1,48 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/and3.sc b/test/sc-ref/and3.sc new file mode 100644 index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569 --- /dev/null +++ b/test/sc-ref/and3.sc @@ -0,0 +1,48 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/and4.sc b/test/sc-ref/and4.sc new file mode 100644 index 0000000000000000000000000000000000000000..f3a30fb72a93ff0e115b3e33b17fee9094697569 --- /dev/null +++ b/test/sc-ref/and4.sc @@ -0,0 +1,48 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/and5.sc b/test/sc-ref/and5.sc new file mode 100644 index 0000000000000000000000000000000000000000..22cd18f28a5a65306ce88711fd082058a2e7bd2c --- /dev/null +++ b/test/sc-ref/and5.sc @@ -0,0 +1,60 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AEtExp1> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/appel-param1.sc b/test/sc-ref/appel-param1.sc new file mode 100644 index 0000000000000000000000000000000000000000..5f242e2f863ea7b72091f37d523f25492e6059ad --- /dev/null +++ b/test/sc-ref/appel-param1.sc @@ -0,0 +1,78 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <AAvecparamListeparam> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AAvecparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <ARecursifListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + </AFinalListeexpbis> + </ARecursifListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/appel-param2.sc b/test/sc-ref/appel-param2.sc new file mode 100644 index 0000000000000000000000000000000000000000..c683b17d10544150d947a9b96eb99c8cabcc829c --- /dev/null +++ b/test/sc-ref/appel-param2.sc @@ -0,0 +1,120 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <AAvecparamListeparam> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AAvecparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <ARecursifListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <ARecursifListeexpbis> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + </AFinalListeexpbis> + </ARecursifListeexpbis> + </ARecursifListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/appel-param3.sc b/test/sc-ref/appel-param3.sc new file mode 100644 index 0000000000000000000000000000000000000000..6aab83be2aa9a3f817025074066e1eb798250afe --- /dev/null +++ b/test/sc-ref/appel-param3.sc @@ -0,0 +1,246 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <AAvecparamListeparam> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarldecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarldecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarldecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvarbis> + </ADecvarldecvarListedecvarbis> + </ADecvarldecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AAvecparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <ARecursifListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <ARecursifListeexpbis> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <ARecursifListeexpbis> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <ARecursifListeexpbis> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <ARecursifListeexpbis> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + </AFinalListeexpbis> + </ARecursifListeexpbis> + </ARecursifListeexpbis> + </ARecursifListeexpbis> + </ARecursifListeexpbis> + </ARecursifListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/appel-retour1.sc b/test/sc-ref/appel-retour1.sc new file mode 100644 index 0000000000000000000000000000000000000000..64940ad64c06078e8060d5e3f12eeabb325c4b2c --- /dev/null +++ b/test/sc-ref/appel-retour1.sc @@ -0,0 +1,106 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <AAvecparamListeparam> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AAvecparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrretourInstr> + <AInstrretour> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrretour> + </AInstrretourInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AAppelfctExp6> + <AAppelfct> + <ARecursifListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + </AFinalListeexpbis> + </ARecursifListeexp> + </AAppelfct> + </AAppelfctExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/appel1.sc b/test/sc-ref/appel1.sc new file mode 100644 index 0000000000000000000000000000000000000000..146cd4a3e8bb125dd6ddb7debe5c428c78058ffb --- /dev/null +++ b/test/sc-ref/appel1.sc @@ -0,0 +1,56 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/appel2.sc b/test/sc-ref/appel2.sc new file mode 100644 index 0000000000000000000000000000000000000000..b1e1d36df31c9c31c04d038b448eacaebef1c4fe --- /dev/null +++ b/test/sc-ref/appel2.sc @@ -0,0 +1,96 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/appel3.sc b/test/sc-ref/appel3.sc new file mode 100644 index 0000000000000000000000000000000000000000..1e1737c75cc1ebcbe652ffc91389166348e2e687 --- /dev/null +++ b/test/sc-ref/appel3.sc @@ -0,0 +1,96 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/div1.sc b/test/sc-ref/div1.sc new file mode 100644 index 0000000000000000000000000000000000000000..3ce95c75551cc4c74eb25ad65bb68b9bd65a5da5 --- /dev/null +++ b/test/sc-ref/div1.sc @@ -0,0 +1,42 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <ADiviseExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/div2.sc b/test/sc-ref/div2.sc new file mode 100644 index 0000000000000000000000000000000000000000..3ce95c75551cc4c74eb25ad65bb68b9bd65a5da5 --- /dev/null +++ b/test/sc-ref/div2.sc @@ -0,0 +1,42 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <ADiviseExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/div3.sc b/test/sc-ref/div3.sc new file mode 100644 index 0000000000000000000000000000000000000000..2fe7922a5a5bf64db5d617ac42b1c2b5f4f91ff0 --- /dev/null +++ b/test/sc-ref/div3.sc @@ -0,0 +1,48 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <ADiviseExp4> + <ADiviseExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/div4.sc b/test/sc-ref/div4.sc new file mode 100644 index 0000000000000000000000000000000000000000..3ce95c75551cc4c74eb25ad65bb68b9bd65a5da5 --- /dev/null +++ b/test/sc-ref/div4.sc @@ -0,0 +1,42 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <ADiviseExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/ecrire1.sc b/test/sc-ref/ecrire1.sc new file mode 100644 index 0000000000000000000000000000000000000000..03c62d11fbc895298722782757f614c1e2be261e --- /dev/null +++ b/test/sc-ref/ecrire1.sc @@ -0,0 +1,36 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/ecrire2.sc b/test/sc-ref/ecrire2.sc new file mode 100644 index 0000000000000000000000000000000000000000..03c62d11fbc895298722782757f614c1e2be261e --- /dev/null +++ b/test/sc-ref/ecrire2.sc @@ -0,0 +1,36 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/egal1.sc b/test/sc-ref/egal1.sc new file mode 100644 index 0000000000000000000000000000000000000000..19ab92d9e23815660d1b80ac63b3ed29dfcbf26c --- /dev/null +++ b/test/sc-ref/egal1.sc @@ -0,0 +1,46 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AEgalExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/egal2.sc b/test/sc-ref/egal2.sc new file mode 100644 index 0000000000000000000000000000000000000000..19ab92d9e23815660d1b80ac63b3ed29dfcbf26c --- /dev/null +++ b/test/sc-ref/egal2.sc @@ -0,0 +1,46 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AEgalExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/egal3.sc b/test/sc-ref/egal3.sc new file mode 100644 index 0000000000000000000000000000000000000000..4c55fe83c04086b5963af1a73288b418bd319443 --- /dev/null +++ b/test/sc-ref/egal3.sc @@ -0,0 +1,56 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AEgalExp2> + <AEgalExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/err1.sc b/test/sc-ref/err1.sc new file mode 100644 index 0000000000000000000000000000000000000000..2836d73cd31a01f89feadfeacacd8761e519c15c --- /dev/null +++ b/test/sc-ref/err1.sc @@ -0,0 +1,38 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/err2.sc b/test/sc-ref/err2.sc new file mode 100644 index 0000000000000000000000000000000000000000..2eb2ef9af775dbac73197258ebba340db3fd9e19 --- /dev/null +++ b/test/sc-ref/err2.sc @@ -0,0 +1,26 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/err3.sc b/test/sc-ref/err3.sc new file mode 100644 index 0000000000000000000000000000000000000000..b159de5537afb74d191f12465258ada67750ccd8 --- /dev/null +++ b/test/sc-ref/err3.sc @@ -0,0 +1,40 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <AAvecparamListeparam> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AAvecparamListeparam> + <AInstrbloc> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/err4.sc b/test/sc-ref/err4.sc new file mode 100644 index 0000000000000000000000000000000000000000..ae87ec482b1d627a4cd26beb413c4313a161140a --- /dev/null +++ b/test/sc-ref/err4.sc @@ -0,0 +1,62 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <AAvecparamListeparam> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AAvecparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <ARecursifListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + </AFinalListeexpbis> + </ARecursifListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/err5.sc b/test/sc-ref/err5.sc new file mode 100644 index 0000000000000000000000000000000000000000..6e983507c48e7924c38675666aa98b28a33b2144 --- /dev/null +++ b/test/sc-ref/err5.sc @@ -0,0 +1,78 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AAppelfctExp6> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AAppelfctExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/fibo.sc b/test/sc-ref/fibo.sc new file mode 100644 index 0000000000000000000000000000000000000000..f6f4346cede20ca40faf792af1e7e281253f03d4 --- /dev/null +++ b/test/sc-ref/fibo.sc @@ -0,0 +1,248 @@ +<Start> + <AProgramme> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <ARecursifListedecfonc> + <ADecfonc> + <AEntierOpttype> + </AEntierOpttype> + <APremierListedecvar> + <AScalaireDecvar> + <AEntierType> + </AEntierType> + </AScalaireDecvar> + <AFinalListedecvarbis> + <AEpsilon> + </AEpsilon> + </AFinalListedecvarbis> + </APremierListedecvar> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <AInstrbloc> + <ARecursifListeinst> + <ASinonInstr> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <ASimpleVar> + </ASimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ARecursifListeinst> + <ARetourInstr> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </ARetourInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + <AInstrbloc> + <ARecursifListeinst> + <ARetourInstr> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AAppelfctExp6> + <AAppelfct> + <APremierListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <ASimpleVar> + </ASimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + <AEpsilon> + </AEpsilon> + </AFinalListeexpbis> + </APremierListeexp> + </AAppelfct> + </AAppelfctExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AAppelfctExp6> + <AAppelfct> + <APremierListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <ASimpleVar> + </ASimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + <AEpsilon> + </AEpsilon> + </AFinalListeexpbis> + </APremierListeexp> + </AAppelfct> + </AAppelfctExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </ARetourInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + </ASinonInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + </ADecfonc> + <ARecursifListedecfonc> + <ADecfonc> + <AVideOpttype> + </AVideOpttype> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <AInstrbloc> + <ARecursifListeinst> + <AEcritureInstr> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AAppelfctExp6> + <AAppelfct> + <APremierListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + <AEpsilon> + </AEpsilon> + </AFinalListeexpbis> + </APremierListeexp> + </AAppelfct> + </AAppelfctExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AEcritureInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + </ADecfonc> + <AFinalListedecfonc> + <AEpsilon> + </AEpsilon> + </AFinalListedecfonc> + </ARecursifListedecfonc> + </ARecursifListedecfonc> + </AProgramme> +</Start> diff --git a/test/sc-ref/inf1.sc b/test/sc-ref/inf1.sc new file mode 100644 index 0000000000000000000000000000000000000000..6daf211e6b52ca44419bc128e39a77a41fb350c9 --- /dev/null +++ b/test/sc-ref/inf1.sc @@ -0,0 +1,46 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/inf2.sc b/test/sc-ref/inf2.sc new file mode 100644 index 0000000000000000000000000000000000000000..6daf211e6b52ca44419bc128e39a77a41fb350c9 --- /dev/null +++ b/test/sc-ref/inf2.sc @@ -0,0 +1,46 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/inf3.sc b/test/sc-ref/inf3.sc new file mode 100644 index 0000000000000000000000000000000000000000..6daf211e6b52ca44419bc128e39a77a41fb350c9 --- /dev/null +++ b/test/sc-ref/inf3.sc @@ -0,0 +1,46 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/inf4.sc b/test/sc-ref/inf4.sc new file mode 100644 index 0000000000000000000000000000000000000000..4804d6f1e76514fd68ff0d48bcdbfb4b555a3dd1 --- /dev/null +++ b/test/sc-ref/inf4.sc @@ -0,0 +1,56 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/modulo1.sc b/test/sc-ref/modulo1.sc new file mode 100644 index 0000000000000000000000000000000000000000..470dfbf46112fa0b40c8a00ade74e3ec3cdc6d5b --- /dev/null +++ b/test/sc-ref/modulo1.sc @@ -0,0 +1,42 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AModuloExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AModuloExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/mult1.sc b/test/sc-ref/mult1.sc new file mode 100644 index 0000000000000000000000000000000000000000..43b5a18c6b58557388531f691192174d40dd2737 --- /dev/null +++ b/test/sc-ref/mult1.sc @@ -0,0 +1,42 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AFoisExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AFoisExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/mult2.sc b/test/sc-ref/mult2.sc new file mode 100644 index 0000000000000000000000000000000000000000..43b5a18c6b58557388531f691192174d40dd2737 --- /dev/null +++ b/test/sc-ref/mult2.sc @@ -0,0 +1,42 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AFoisExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AFoisExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/mult3.sc b/test/sc-ref/mult3.sc new file mode 100644 index 0000000000000000000000000000000000000000..ed24546b2b752eae7491aba8b1994dad2cb79252 --- /dev/null +++ b/test/sc-ref/mult3.sc @@ -0,0 +1,48 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AFoisExp4> + <AFoisExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AFoisExp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AFoisExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/not1.sc b/test/sc-ref/not1.sc new file mode 100644 index 0000000000000000000000000000000000000000..f1def7ef8ee6936812a31a3a870abac25cfa32b9 --- /dev/null +++ b/test/sc-ref/not1.sc @@ -0,0 +1,38 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/not2.sc b/test/sc-ref/not2.sc new file mode 100644 index 0000000000000000000000000000000000000000..f1def7ef8ee6936812a31a3a870abac25cfa32b9 --- /dev/null +++ b/test/sc-ref/not2.sc @@ -0,0 +1,38 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/not3.sc b/test/sc-ref/not3.sc new file mode 100644 index 0000000000000000000000000000000000000000..c72880b10dddc5a590103842dff5826701a78eb0 --- /dev/null +++ b/test/sc-ref/not3.sc @@ -0,0 +1,40 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <ANonExp5> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </ANonExp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/or1.sc b/test/sc-ref/or1.sc new file mode 100644 index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430 --- /dev/null +++ b/test/sc-ref/or1.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AOuExp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AOuExp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/or2.sc b/test/sc-ref/or2.sc new file mode 100644 index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430 --- /dev/null +++ b/test/sc-ref/or2.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AOuExp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AOuExp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/or3.sc b/test/sc-ref/or3.sc new file mode 100644 index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430 --- /dev/null +++ b/test/sc-ref/or3.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AOuExp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AOuExp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/or4.sc b/test/sc-ref/or4.sc new file mode 100644 index 0000000000000000000000000000000000000000..35d8279fca89b67a877c9fc9b2b2ad316695a430 --- /dev/null +++ b/test/sc-ref/or4.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AOuExp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AOuExp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/or5.sc b/test/sc-ref/or5.sc new file mode 100644 index 0000000000000000000000000000000000000000..954b836e8137a328b1a7b23111e9ad442dcaec05 --- /dev/null +++ b/test/sc-ref/or5.sc @@ -0,0 +1,64 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AOuExp> + <AOuExp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AOuExp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AOuExp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/parenth1.sc b/test/sc-ref/parenth1.sc new file mode 100644 index 0000000000000000000000000000000000000000..6e5d8d2385ff1a239c88095d7942a273f0c7214f --- /dev/null +++ b/test/sc-ref/parenth1.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/parenth2.sc b/test/sc-ref/parenth2.sc new file mode 100644 index 0000000000000000000000000000000000000000..eff72be83c53c7c8dc2f6a93b700a0ee8a0f543f --- /dev/null +++ b/test/sc-ref/parenth2.sc @@ -0,0 +1,64 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio23-1.sc b/test/sc-ref/prio23-1.sc new file mode 100644 index 0000000000000000000000000000000000000000..d19611ddd81e953c342eb7e980427db4239f7944 --- /dev/null +++ b/test/sc-ref/prio23-1.sc @@ -0,0 +1,44 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AFoisExp4> + <AExp5Exp4> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AFoisExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio23-2.sc b/test/sc-ref/prio23-2.sc new file mode 100644 index 0000000000000000000000000000000000000000..41731ecc7c25dcffa320e6d00b4461d4412f074c --- /dev/null +++ b/test/sc-ref/prio23-2.sc @@ -0,0 +1,44 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AFoisExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </AFoisExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio23-3.sc b/test/sc-ref/prio23-3.sc new file mode 100644 index 0000000000000000000000000000000000000000..fc90db428a8474c7f36b22e87250379dfe7118cf --- /dev/null +++ b/test/sc-ref/prio23-3.sc @@ -0,0 +1,44 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <ADiviseExp4> + <AExp5Exp4> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio23-4.sc b/test/sc-ref/prio23-4.sc new file mode 100644 index 0000000000000000000000000000000000000000..9e096755df901a550803b9acb493ea0033a18860 --- /dev/null +++ b/test/sc-ref/prio23-4.sc @@ -0,0 +1,46 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <ADiviseExp4> + <AExp5Exp4> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </AExp5Exp4> + <ANonExp5> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ANonExp5> + </ADiviseExp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio34-1.sc b/test/sc-ref/prio34-1.sc new file mode 100644 index 0000000000000000000000000000000000000000..b91f1fb0686012c5df322c3fd619f4a9e3482f92 --- /dev/null +++ b/test/sc-ref/prio34-1.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AFoisExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AFoisExp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio34-2.sc b/test/sc-ref/prio34-2.sc new file mode 100644 index 0000000000000000000000000000000000000000..83731e75a1fa8196b2c93895fffe83fe17202dc3 --- /dev/null +++ b/test/sc-ref/prio34-2.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AFoisExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AFoisExp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio34-3.sc b/test/sc-ref/prio34-3.sc new file mode 100644 index 0000000000000000000000000000000000000000..c2ea56d38f6f86cc6dc0e15e2cb823dc0bd38b6d --- /dev/null +++ b/test/sc-ref/prio34-3.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <ADiviseExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio34-4.sc b/test/sc-ref/prio34-4.sc new file mode 100644 index 0000000000000000000000000000000000000000..3e2860a9dfe4713f1379c2d3455eb919fc7bde62 --- /dev/null +++ b/test/sc-ref/prio34-4.sc @@ -0,0 +1,50 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <ADiviseExp4> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </ADiviseExp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio45-1.sc b/test/sc-ref/prio45-1.sc new file mode 100644 index 0000000000000000000000000000000000000000..76d3b8d04e93b006e4d7b57afa96c3fe6d8dc18b --- /dev/null +++ b/test/sc-ref/prio45-1.sc @@ -0,0 +1,54 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AEgalExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AEgalExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio45-2.sc b/test/sc-ref/prio45-2.sc new file mode 100644 index 0000000000000000000000000000000000000000..721d838f8dc47d395bcc1e3af3f212ab712d7856 --- /dev/null +++ b/test/sc-ref/prio45-2.sc @@ -0,0 +1,54 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AEgalExp2> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio45-3.sc b/test/sc-ref/prio45-3.sc new file mode 100644 index 0000000000000000000000000000000000000000..5777f26f63bed1dc8246bb031ae61565acbf6c06 --- /dev/null +++ b/test/sc-ref/prio45-3.sc @@ -0,0 +1,54 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio45-4.sc b/test/sc-ref/prio45-4.sc new file mode 100644 index 0000000000000000000000000000000000000000..02dd9dd82feb9edfe2df2c8626e2b9a359efaafa --- /dev/null +++ b/test/sc-ref/prio45-4.sc @@ -0,0 +1,54 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio56-1.sc b/test/sc-ref/prio56-1.sc new file mode 100644 index 0000000000000000000000000000000000000000..a59126e8a317066ca0eb78f6694f3e20f7f0bc06 --- /dev/null +++ b/test/sc-ref/prio56-1.sc @@ -0,0 +1,58 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AEgalExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio56-2.sc b/test/sc-ref/prio56-2.sc new file mode 100644 index 0000000000000000000000000000000000000000..480375b5af5cb27d25b1de0718aa8f516c15e2ad --- /dev/null +++ b/test/sc-ref/prio56-2.sc @@ -0,0 +1,58 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AEgalExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + </AEtExp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio67-1.sc b/test/sc-ref/prio67-1.sc new file mode 100644 index 0000000000000000000000000000000000000000..f096c7c8cdfb7a99c40bc24c050c3594d4eca0a9 --- /dev/null +++ b/test/sc-ref/prio67-1.sc @@ -0,0 +1,62 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AOuExp> + <AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AOuExp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/prio67-2.sc b/test/sc-ref/prio67-2.sc new file mode 100644 index 0000000000000000000000000000000000000000..9bb0df80e9aa6e023936d46257ce357c02fbcc7c --- /dev/null +++ b/test/sc-ref/prio67-2.sc @@ -0,0 +1,62 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AOuExp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AEtExp1> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AEtExp1> + </AOuExp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/rec1.sc b/test/sc-ref/rec1.sc new file mode 100644 index 0000000000000000000000000000000000000000..1f75e3997f0fd594e3727c7c662f9f0cb1eb3da7 --- /dev/null +++ b/test/sc-ref/rec1.sc @@ -0,0 +1,258 @@ +<Start> + <AProgramme> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <ARecursifListedecfonc> + <ADecfonc> + <AEntierOpttype> + </AEntierOpttype> + <APremierListedecvar> + <AScalaireDecvar> + <AEntierType> + </AEntierType> + </AScalaireDecvar> + <AFinalListedecvarbis> + <AEpsilon> + </AEpsilon> + </AFinalListedecvarbis> + </APremierListedecvar> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <AInstrbloc> + <ARecursifListeinst> + <ASinonInstr> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AEgalExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <ASimpleVar> + </ASimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AEgalExp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ARecursifListeinst> + <ARetourInstr> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </ARetourInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + <AInstrbloc> + <ARecursifListeinst> + <ARetourInstr> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AAppelfctExp6> + <AAppelfct> + <APremierListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <ASimpleVar> + </ASimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + <AEpsilon> + </AEpsilon> + </AFinalListeexpbis> + </APremierListeexp> + </AAppelfct> + </AAppelfctExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </ARetourInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + </ASinonInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + </ADecfonc> + <ARecursifListedecfonc> + <ADecfonc> + <AVideOpttype> + </AVideOpttype> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <AVideListedecvar> + <AEpsilon> + </AEpsilon> + </AVideListedecvar> + <AInstrbloc> + <ARecursifListeinst> + <AEcritureInstr> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AAppelfctExp6> + <AAppelfct> + <APremierListeexp> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AFinalListeexpbis> + <AEpsilon> + </AEpsilon> + </AFinalListeexpbis> + </APremierListeexp> + </AAppelfct> + </AAppelfctExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AEcritureInstr> + <AFinalListeinst> + <AEpsilon> + </AEpsilon> + </AFinalListeinst> + </ARecursifListeinst> + </AInstrbloc> + </ADecfonc> + <AFinalListedecfonc> + <AEpsilon> + </AEpsilon> + </AFinalListedecfonc> + </ARecursifListedecfonc> + </ARecursifListedecfonc> + </AProgramme> +</Start> diff --git a/test/sc-ref/si1.sc b/test/sc-ref/si1.sc new file mode 100644 index 0000000000000000000000000000000000000000..f2146b7ffa5af0fe1e053da5c9cc7c8e3588bf4a --- /dev/null +++ b/test/sc-ref/si1.sc @@ -0,0 +1,74 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrsiInstr> + <ASanssinonInstrsi> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ASanssinonInstrsi> + </AInstrsiInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/si2.sc b/test/sc-ref/si2.sc new file mode 100644 index 0000000000000000000000000000000000000000..ac02bca9f7d61142662d49d1fb0b51f16d66a508 --- /dev/null +++ b/test/sc-ref/si2.sc @@ -0,0 +1,100 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrsiInstr> + <AAvecsinonInstrsi> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + <AInstrsinon> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrsinon> + </AAvecsinonInstrsi> + </AInstrsiInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/si3.sc b/test/sc-ref/si3.sc new file mode 100644 index 0000000000000000000000000000000000000000..d209790b642114496108c5f9c419fbe1388ab2bd --- /dev/null +++ b/test/sc-ref/si3.sc @@ -0,0 +1,120 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrsiInstr> + <AAvecsinonInstrsi> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + <AInstrsinon> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrsinon> + </AAvecsinonInstrsi> + </AInstrsiInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/si4.sc b/test/sc-ref/si4.sc new file mode 100644 index 0000000000000000000000000000000000000000..d209790b642114496108c5f9c419fbe1388ab2bd --- /dev/null +++ b/test/sc-ref/si4.sc @@ -0,0 +1,120 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrsiInstr> + <AAvecsinonInstrsi> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + <AInstrsinon> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrsinon> + </AAvecsinonInstrsi> + </AInstrsiInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/si5.sc b/test/sc-ref/si5.sc new file mode 100644 index 0000000000000000000000000000000000000000..63490b683435b938ff34909ca226d879b5d0c5c0 --- /dev/null +++ b/test/sc-ref/si5.sc @@ -0,0 +1,152 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrsiInstr> + <ASanssinonInstrsi> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrsiInstr> + <ASanssinonInstrsi> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ASanssinonInstrsi> + </AInstrsiInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ASanssinonInstrsi> + </AInstrsiInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/sub1.sc b/test/sc-ref/sub1.sc new file mode 100644 index 0000000000000000000000000000000000000000..67c24adf3829eaa4aca3793b722206f5a8caa7e9 --- /dev/null +++ b/test/sc-ref/sub1.sc @@ -0,0 +1,44 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/sub2.sc b/test/sc-ref/sub2.sc new file mode 100644 index 0000000000000000000000000000000000000000..67c24adf3829eaa4aca3793b722206f5a8caa7e9 --- /dev/null +++ b/test/sc-ref/sub2.sc @@ -0,0 +1,44 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/sub3.sc b/test/sc-ref/sub3.sc new file mode 100644 index 0000000000000000000000000000000000000000..8cc3d2b070cda1bdeb6b60619aa5fc2d16057501 --- /dev/null +++ b/test/sc-ref/sub3.sc @@ -0,0 +1,52 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/tab1.sc b/test/sc-ref/tab1.sc new file mode 100644 index 0000000000000000000000000000000000000000..566a603ace561fd55c0f13996bb976e7588f9a2b --- /dev/null +++ b/test/sc-ref/tab1.sc @@ -0,0 +1,238 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvartableauDecvar> + </ADecvartableauDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/tab2.sc b/test/sc-ref/tab2.sc new file mode 100644 index 0000000000000000000000000000000000000000..f0b76e5deded94f2c2308e99fc8ac37294f6c524 --- /dev/null +++ b/test/sc-ref/tab2.sc @@ -0,0 +1,296 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvartableauDecvar> + </ADecvartableauDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/tab3.sc b/test/sc-ref/tab3.sc new file mode 100644 index 0000000000000000000000000000000000000000..bc763934d6940d7f5b02c03ad9e3db077415563d --- /dev/null +++ b/test/sc-ref/tab3.sc @@ -0,0 +1,372 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvartableauDecvar> + </ADecvartableauDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/tab4.sc b/test/sc-ref/tab4.sc new file mode 100644 index 0000000000000000000000000000000000000000..b8a0b76caa1d7b2e504b9385c771aa4ae3802027 --- /dev/null +++ b/test/sc-ref/tab4.sc @@ -0,0 +1,278 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvartableauDecvar> + </ADecvartableauDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVartabVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AVartabVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/tantque1.sc b/test/sc-ref/tantque1.sc new file mode 100644 index 0000000000000000000000000000000000000000..4f9e5eb8a2f3daa485f0fb495c2f583e3e6f7b0f --- /dev/null +++ b/test/sc-ref/tantque1.sc @@ -0,0 +1,168 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrtantqueInstr> + <AInstrtantque> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AMoinsExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AMoinsExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrtantque> + </AInstrtantqueInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/tantque2.sc b/test/sc-ref/tantque2.sc new file mode 100644 index 0000000000000000000000000000000000000000..bc41df0c5ef2e8b5f3413607c1a7552f38ae4468 --- /dev/null +++ b/test/sc-ref/tantque2.sc @@ -0,0 +1,278 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrtantqueInstr> + <AInstrtantque> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrtantqueInstr> + <AInstrtantque> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AParenthesesExp6> + <AExp1Exp> + <AExp2Exp1> + <AInfExp2> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AInfExp2> + </AExp2Exp1> + </AExp1Exp> + </AParenthesesExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + <AInstrbloc> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrtantque> + </AInstrtantqueInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrtantque> + </AInstrtantqueInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/varglob1.sc b/test/sc-ref/varglob1.sc new file mode 100644 index 0000000000000000000000000000000000000000..919a43405a186954fd65d20f556024a803342d62 --- /dev/null +++ b/test/sc-ref/varglob1.sc @@ -0,0 +1,66 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/varglob2.sc b/test/sc-ref/varglob2.sc new file mode 100644 index 0000000000000000000000000000000000000000..96bbeca7222b19f46d627ecfb093807c15ae2f2c --- /dev/null +++ b/test/sc-ref/varglob2.sc @@ -0,0 +1,74 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/varglob3.sc b/test/sc-ref/varglob3.sc new file mode 100644 index 0000000000000000000000000000000000000000..f4d53628cd5ec6c660d1ede103430f847eab9ffe --- /dev/null +++ b/test/sc-ref/varglob3.sc @@ -0,0 +1,114 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/varglob4.sc b/test/sc-ref/varglob4.sc new file mode 100644 index 0000000000000000000000000000000000000000..9cd98686cc44b071aafdece2a2a3e71dfa15723f --- /dev/null +++ b/test/sc-ref/varglob4.sc @@ -0,0 +1,102 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/sc-ref/varloc1.sc b/test/sc-ref/varloc1.sc new file mode 100644 index 0000000000000000000000000000000000000000..55761e9d89bd27bd62295bbd738b4e7d185f96a2 --- /dev/null +++ b/test/sc-ref/varloc1.sc @@ -0,0 +1,66 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/varloc2.sc b/test/sc-ref/varloc2.sc new file mode 100644 index 0000000000000000000000000000000000000000..87932be72db67199f1418f43d14cc7552053427e --- /dev/null +++ b/test/sc-ref/varloc2.sc @@ -0,0 +1,74 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/varloc3.sc b/test/sc-ref/varloc3.sc new file mode 100644 index 0000000000000000000000000000000000000000..4d594da2414c187d00f54716a040762856767655 --- /dev/null +++ b/test/sc-ref/varloc3.sc @@ -0,0 +1,114 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/varloc4.sc b/test/sc-ref/varloc4.sc new file mode 100644 index 0000000000000000000000000000000000000000..e6e9d7d23f16e8c6619fedf40def802c5d87d4a7 --- /dev/null +++ b/test/sc-ref/varloc4.sc @@ -0,0 +1,102 @@ +<Start> + <ALdecfoncProgramme> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarldecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + <ADecvarListedecvarbis> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvarbis> + </ADecvarldecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <APlusExp3> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </APlusExp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncProgramme> +</Start> diff --git a/test/sc-ref/varloc5.sc b/test/sc-ref/varloc5.sc new file mode 100644 index 0000000000000000000000000000000000000000..92acf2b7cd60eca257ef5a3d312d3c0b105b1642 --- /dev/null +++ b/test/sc-ref/varloc5.sc @@ -0,0 +1,136 @@ +<Start> + <ADecvarldecfoncProgramme> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <ALdecfoncrecListedecfonc> + <ADecvarinstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AOptdecvar> + <ADecvarListedecvar> + <ADecvarentierDecvar> + </ADecvarentierDecvar> + </ADecvarListedecvar> + </AOptdecvar> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </ADecvarinstrDecfonc> + <ALdecfoncrecListedecfonc> + <AInstrDecfonc> + <ASansparamListeparam> + </ASansparamListeparam> + <AInstrbloc> + <ALinstrecListeinst> + <AInstraffectInstr> + <AInstraffect> + <AVarsimpleVar> + </AVarsimpleVar> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <ANombreExp6> + </ANombreExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstraffect> + </AInstraffectInstr> + <ALinstrecListeinst> + <AInstrappelInstr> + <AInstrappel> + <AAppelfct> + <AFinalListeexp> + </AFinalListeexp> + </AAppelfct> + </AInstrappel> + </AInstrappelInstr> + <ALinstrecListeinst> + <AInstrecritureInstr> + <AInstrecriture> + <AExp1Exp> + <AExp2Exp1> + <AExp3Exp2> + <AExp4Exp3> + <AExp5Exp4> + <AExp6Exp5> + <AVarExp6> + <AVarsimpleVar> + </AVarsimpleVar> + </AVarExp6> + </AExp6Exp5> + </AExp5Exp4> + </AExp4Exp3> + </AExp3Exp2> + </AExp2Exp1> + </AExp1Exp> + </AInstrecriture> + </AInstrecritureInstr> + <ALinstfinalListeinst> + </ALinstfinalListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </ALinstrecListeinst> + </AInstrbloc> + </AInstrDecfonc> + <ALdecfoncfinalListedecfonc> + </ALdecfoncfinalListedecfonc> + </ALdecfoncrecListedecfonc> + </ALdecfoncrecListedecfonc> + </ADecvarldecfoncProgramme> +</Start> diff --git a/test/ts-ref/add1.ts b/test/ts-ref/add1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/add1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/add2.ts b/test/ts-ref/add2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/add2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/affect1.ts b/test/ts-ref/affect1.ts new file mode 100644 index 0000000000000000000000000000000000000000..f223443e9d97dde78efbca5e6b59a7babdbdad38 --- /dev/null +++ b/test/ts-ref/affect1.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +a VAR entier 0 +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/affect2.ts b/test/ts-ref/affect2.ts new file mode 100644 index 0000000000000000000000000000000000000000..53497cf7f8021a9a552389d69dc902e4b23b143f --- /dev/null +++ b/test/ts-ref/affect2.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main +a VAR entier 0 diff --git a/test/ts-ref/affect3.ts b/test/ts-ref/affect3.ts new file mode 100644 index 0000000000000000000000000000000000000000..e4357a9135505f2224c6b9e93064d64a9fff071a --- /dev/null +++ b/test/ts-ref/affect3.ts @@ -0,0 +1,7 @@ +TABLE GLOBALE +f FCT nul 1 +main FCT nul 0 +TABLE LOCALE : f +a PARAM entier 0 +TABLE LOCALE : main +a VAR entier 0 diff --git a/test/ts-ref/and1.ts b/test/ts-ref/and1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/and1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/and2.ts b/test/ts-ref/and2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/and2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/and3.ts b/test/ts-ref/and3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/and3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/and4.ts b/test/ts-ref/and4.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/and4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/and5.ts b/test/ts-ref/and5.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/and5.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/appel-param1.ts b/test/ts-ref/appel-param1.ts new file mode 100644 index 0000000000000000000000000000000000000000..cc61134c3827ee792ca7b378d28620f75a27f793 --- /dev/null +++ b/test/ts-ref/appel-param1.ts @@ -0,0 +1,6 @@ +TABLE GLOBALE +f FCT nul 1 +main FCT nul 0 +TABLE LOCALE : f +a PARAM entier 0 +TABLE LOCALE : main diff --git a/test/ts-ref/appel-param2.ts b/test/ts-ref/appel-param2.ts new file mode 100644 index 0000000000000000000000000000000000000000..eced11b659314938f13c703734267c683c173b19 --- /dev/null +++ b/test/ts-ref/appel-param2.ts @@ -0,0 +1,7 @@ +TABLE GLOBALE +f FCT nul 2 +main FCT nul 0 +TABLE LOCALE : f +a PARAM entier 0 +b PARAM entier 4 +TABLE LOCALE : main diff --git a/test/ts-ref/appel-param3.ts b/test/ts-ref/appel-param3.ts new file mode 100644 index 0000000000000000000000000000000000000000..c967f70cb314dc370e60659664d2a46f6549c1f4 --- /dev/null +++ b/test/ts-ref/appel-param3.ts @@ -0,0 +1,10 @@ +TABLE GLOBALE +f FCT nul 5 +main FCT nul 0 +TABLE LOCALE : f +a PARAM entier 0 +b PARAM entier 4 +c PARAM entier 8 +d PARAM entier 12 +e PARAM entier 16 +TABLE LOCALE : main diff --git a/test/ts-ref/appel-retour1.ts b/test/ts-ref/appel-retour1.ts new file mode 100644 index 0000000000000000000000000000000000000000..9b80e9aa53dfc52f0246cdd41099ac2c03ab28ad --- /dev/null +++ b/test/ts-ref/appel-retour1.ts @@ -0,0 +1,6 @@ +TABLE GLOBALE +f FCT entier 1 +main FCT nul 0 +TABLE LOCALE : f +a PARAM entier 0 +TABLE LOCALE : main diff --git a/test/ts-ref/appel1.ts b/test/ts-ref/appel1.ts new file mode 100644 index 0000000000000000000000000000000000000000..0761e6dbf57494ec7710290ccfcf9071ee927b84 --- /dev/null +++ b/test/ts-ref/appel1.ts @@ -0,0 +1,5 @@ +TABLE GLOBALE +f FCT nul 0 +main FCT nul 0 +TABLE LOCALE : f +TABLE LOCALE : main diff --git a/test/ts-ref/appel2.ts b/test/ts-ref/appel2.ts new file mode 100644 index 0000000000000000000000000000000000000000..9e966d9f76a67f7a8918adaec9bc9a19483aa08c --- /dev/null +++ b/test/ts-ref/appel2.ts @@ -0,0 +1,7 @@ +TABLE GLOBALE +f FCT nul 0 +g FCT nul 0 +main FCT nul 0 +TABLE LOCALE : f +TABLE LOCALE : g +TABLE LOCALE : main diff --git a/test/ts-ref/appel3.ts b/test/ts-ref/appel3.ts new file mode 100644 index 0000000000000000000000000000000000000000..9e966d9f76a67f7a8918adaec9bc9a19483aa08c --- /dev/null +++ b/test/ts-ref/appel3.ts @@ -0,0 +1,7 @@ +TABLE GLOBALE +f FCT nul 0 +g FCT nul 0 +main FCT nul 0 +TABLE LOCALE : f +TABLE LOCALE : g +TABLE LOCALE : main diff --git a/test/ts-ref/div1.ts b/test/ts-ref/div1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/div1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/div2.ts b/test/ts-ref/div2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/div2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/div3.ts b/test/ts-ref/div3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/div3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/div4.ts b/test/ts-ref/div4.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/div4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/ecrire1.ts b/test/ts-ref/ecrire1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/ecrire1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/ecrire2.ts b/test/ts-ref/ecrire2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/ecrire2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/egal1.ts b/test/ts-ref/egal1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/egal1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/egal2.ts b/test/ts-ref/egal2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/egal2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/egal3.ts b/test/ts-ref/egal3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/egal3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/err5.ts b/test/ts-ref/err5.ts new file mode 100644 index 0000000000000000000000000000000000000000..f53ebb0c0cd3527a6dbdbbc3772fa451a2b381ab --- /dev/null +++ b/test/ts-ref/err5.ts @@ -0,0 +1,6 @@ +TABLE GLOBALE +f FCT 0 +main FCT 0 +TABLE LOCALE : f +TABLE LOCALE : main +f VAR 1 0 diff --git a/test/ts-ref/fibo.ts b/test/ts-ref/fibo.ts new file mode 100644 index 0000000000000000000000000000000000000000..49fbafbe67ba72c5ad7120295cea6d3ebf8781c7 --- /dev/null +++ b/test/ts-ref/fibo.ts @@ -0,0 +1,6 @@ +TABLE GLOBALE +fibo FCT entier 1 +main FCT nul 0 +TABLE LOCALE : fibo +n PARAM entier 0 +TABLE LOCALE : main diff --git a/test/ts-ref/inf1.ts b/test/ts-ref/inf1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/inf1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/inf2.ts b/test/ts-ref/inf2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/inf2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/inf3.ts b/test/ts-ref/inf3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/inf3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/inf4.ts b/test/ts-ref/inf4.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6 --- /dev/null +++ b/test/ts-ref/inf4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT 0 +TABLE LOCALE : main diff --git a/test/ts-ref/modulo1.ts b/test/ts-ref/modulo1.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6 --- /dev/null +++ b/test/ts-ref/modulo1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT 0 +TABLE LOCALE : main diff --git a/test/ts-ref/mult1.ts b/test/ts-ref/mult1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/mult1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/mult2.ts b/test/ts-ref/mult2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/mult2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/mult3.ts b/test/ts-ref/mult3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/mult3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/not1.ts b/test/ts-ref/not1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/not1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/not2.ts b/test/ts-ref/not2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/not2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/not3.ts b/test/ts-ref/not3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/not3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/or1.ts b/test/ts-ref/or1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/or1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/or2.ts b/test/ts-ref/or2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/or2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/or3.ts b/test/ts-ref/or3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/or3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/or4.ts b/test/ts-ref/or4.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/or4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/or5.ts b/test/ts-ref/or5.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/or5.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/parenth1.ts b/test/ts-ref/parenth1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/parenth1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/parenth2.ts b/test/ts-ref/parenth2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/parenth2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio23-1.ts b/test/ts-ref/prio23-1.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6 --- /dev/null +++ b/test/ts-ref/prio23-1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio23-2.ts b/test/ts-ref/prio23-2.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6 --- /dev/null +++ b/test/ts-ref/prio23-2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio23-3.ts b/test/ts-ref/prio23-3.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6 --- /dev/null +++ b/test/ts-ref/prio23-3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio23-4.ts b/test/ts-ref/prio23-4.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e8bb82f5c295d85a4f53d929c0eb9a18f55ecd6 --- /dev/null +++ b/test/ts-ref/prio23-4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio34-1.ts b/test/ts-ref/prio34-1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio34-1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio34-2.ts b/test/ts-ref/prio34-2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio34-2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio34-3.ts b/test/ts-ref/prio34-3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio34-3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio34-4.ts b/test/ts-ref/prio34-4.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio34-4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio45-1.ts b/test/ts-ref/prio45-1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio45-1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio45-2.ts b/test/ts-ref/prio45-2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio45-2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio45-3.ts b/test/ts-ref/prio45-3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio45-3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio45-4.ts b/test/ts-ref/prio45-4.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio45-4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio56-1.ts b/test/ts-ref/prio56-1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio56-1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio56-2.ts b/test/ts-ref/prio56-2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio56-2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio67-1.ts b/test/ts-ref/prio67-1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio67-1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/prio67-2.ts b/test/ts-ref/prio67-2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/prio67-2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/rec1.ts b/test/ts-ref/rec1.ts new file mode 100644 index 0000000000000000000000000000000000000000..9b80e9aa53dfc52f0246cdd41099ac2c03ab28ad --- /dev/null +++ b/test/ts-ref/rec1.ts @@ -0,0 +1,6 @@ +TABLE GLOBALE +f FCT entier 1 +main FCT nul 0 +TABLE LOCALE : f +a PARAM entier 0 +TABLE LOCALE : main diff --git a/test/ts-ref/si1.ts b/test/ts-ref/si1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/si1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/si2.ts b/test/ts-ref/si2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/si2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/si3.ts b/test/ts-ref/si3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/si3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/si4.ts b/test/ts-ref/si4.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/si4.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/si5.ts b/test/ts-ref/si5.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/si5.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/sub1.ts b/test/ts-ref/sub1.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/sub1.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/sub2.ts b/test/ts-ref/sub2.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/sub2.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/sub3.ts b/test/ts-ref/sub3.ts new file mode 100644 index 0000000000000000000000000000000000000000..6b21c85dc34c7a75e67fc4ed59fb2e81df5afd70 --- /dev/null +++ b/test/ts-ref/sub3.ts @@ -0,0 +1,3 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/tab1.ts b/test/ts-ref/tab1.ts new file mode 100644 index 0000000000000000000000000000000000000000..1b4c6467f2c1f556c0b42c35a79c461c2631f187 --- /dev/null +++ b/test/ts-ref/tab1.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +tab TAB entier 0 3 +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/tab2.ts b/test/ts-ref/tab2.ts new file mode 100644 index 0000000000000000000000000000000000000000..5a98869e3efd88268eb037b03c7c5071f1878027 --- /dev/null +++ b/test/ts-ref/tab2.ts @@ -0,0 +1,5 @@ +TABLE GLOBALE +tab TAB entier 0 5 +main FCT nul 0 +TABLE LOCALE : main +base VAR entier 0 diff --git a/test/ts-ref/tab3.ts b/test/ts-ref/tab3.ts new file mode 100644 index 0000000000000000000000000000000000000000..f04742be14df03faf18e3b07b518008ced4a71cb --- /dev/null +++ b/test/ts-ref/tab3.ts @@ -0,0 +1,6 @@ +TABLE GLOBALE +tab TAB entier 0 5 +main FCT nul 0 +TABLE LOCALE : main +base VAR entier 0 +offset VAR entier 4 diff --git a/test/ts-ref/tab4.ts b/test/ts-ref/tab4.ts new file mode 100644 index 0000000000000000000000000000000000000000..1b4c6467f2c1f556c0b42c35a79c461c2631f187 --- /dev/null +++ b/test/ts-ref/tab4.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +tab TAB entier 0 3 +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/tantque1.ts b/test/ts-ref/tantque1.ts new file mode 100644 index 0000000000000000000000000000000000000000..53497cf7f8021a9a552389d69dc902e4b23b143f --- /dev/null +++ b/test/ts-ref/tantque1.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main +a VAR entier 0 diff --git a/test/ts-ref/tantque2.ts b/test/ts-ref/tantque2.ts new file mode 100644 index 0000000000000000000000000000000000000000..1c4be044e03ba45c24d46305bd1fb5bb4f514d67 --- /dev/null +++ b/test/ts-ref/tantque2.ts @@ -0,0 +1,5 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main +a VAR entier 0 +b VAR entier 4 diff --git a/test/ts-ref/tri.ts b/test/ts-ref/tri.ts new file mode 100644 index 0000000000000000000000000000000000000000..d1113f42474df9a0285c37454b32da9e7d10240c --- /dev/null +++ b/test/ts-ref/tri.ts @@ -0,0 +1,21 @@ +TABLE GLOBALE +tab TAB entier 0 10 +afficher FCT nul 1 +echanger FCT nul 2 +initialiser FCT nul 0 +main FCT nul 0 +trier FCT nul 1 +TABLE LOCALE : afficher +i VAR entier 0 +n PARAM entier 0 +TABLE LOCALE : echanger +i PARAM entier 0 +j PARAM entier 4 +temp VAR entier 0 +TABLE LOCALE : initialiser +TABLE LOCALE : main +TABLE LOCALE : trier +echange VAR entier 0 +j VAR entier 4 +m VAR entier 8 +n PARAM entier 0 diff --git a/test/ts-ref/varglob1.ts b/test/ts-ref/varglob1.ts new file mode 100644 index 0000000000000000000000000000000000000000..18438c4edf93ba9dc9903b8281bf08266bf7dbe3 --- /dev/null +++ b/test/ts-ref/varglob1.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +variable VAR entier 0 +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/varglob2.ts b/test/ts-ref/varglob2.ts new file mode 100644 index 0000000000000000000000000000000000000000..18438c4edf93ba9dc9903b8281bf08266bf7dbe3 --- /dev/null +++ b/test/ts-ref/varglob2.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +variable VAR entier 0 +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/varglob3.ts b/test/ts-ref/varglob3.ts new file mode 100644 index 0000000000000000000000000000000000000000..90950698b368592114f31360f2b9361097457401 --- /dev/null +++ b/test/ts-ref/varglob3.ts @@ -0,0 +1,5 @@ +TABLE GLOBALE +var1 VAR entier 0 +var2 VAR entier 4 +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/varglob4.ts b/test/ts-ref/varglob4.ts new file mode 100644 index 0000000000000000000000000000000000000000..90950698b368592114f31360f2b9361097457401 --- /dev/null +++ b/test/ts-ref/varglob4.ts @@ -0,0 +1,5 @@ +TABLE GLOBALE +var1 VAR entier 0 +var2 VAR entier 4 +main FCT nul 0 +TABLE LOCALE : main diff --git a/test/ts-ref/varloc1.ts b/test/ts-ref/varloc1.ts new file mode 100644 index 0000000000000000000000000000000000000000..43d6f3eedd8f11d4eca3d9abb7fe4c6c1688e2f4 --- /dev/null +++ b/test/ts-ref/varloc1.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main +variable VAR entier 0 diff --git a/test/ts-ref/varloc2.ts b/test/ts-ref/varloc2.ts new file mode 100644 index 0000000000000000000000000000000000000000..43d6f3eedd8f11d4eca3d9abb7fe4c6c1688e2f4 --- /dev/null +++ b/test/ts-ref/varloc2.ts @@ -0,0 +1,4 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main +variable VAR entier 0 diff --git a/test/ts-ref/varloc3.ts b/test/ts-ref/varloc3.ts new file mode 100644 index 0000000000000000000000000000000000000000..1fcf02194803eb9c87f62a700845524cad388338 --- /dev/null +++ b/test/ts-ref/varloc3.ts @@ -0,0 +1,5 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main +var1 VAR entier 0 +var2 VAR entier 4 diff --git a/test/ts-ref/varloc4.ts b/test/ts-ref/varloc4.ts new file mode 100644 index 0000000000000000000000000000000000000000..1fcf02194803eb9c87f62a700845524cad388338 --- /dev/null +++ b/test/ts-ref/varloc4.ts @@ -0,0 +1,5 @@ +TABLE GLOBALE +main FCT nul 0 +TABLE LOCALE : main +var1 VAR entier 0 +var2 VAR entier 4 diff --git a/test/ts-ref/varloc5.ts b/test/ts-ref/varloc5.ts new file mode 100644 index 0000000000000000000000000000000000000000..dfa4f8a05e35f58eb73b6bc1b887fefea9723ec3 --- /dev/null +++ b/test/ts-ref/varloc5.ts @@ -0,0 +1,7 @@ +TABLE GLOBALE +var1 VAR entier 0 +f FCT nul 0 +main FCT nul 0 +TABLE LOCALE : f +var1 VAR entier 0 +TABLE LOCALE : main