Skip to content
Snippets Groups Projects
Commit a31d2647 authored by Nathan PERIER's avatar Nathan PERIER
Browse files

Removed nuples in function definition (too much of a bother for now), added... 

Removed nuples in function definition (too much of a bother for now), added checks for duplicate parameters (close #12)
parent 7782eeca
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/main/java/fr/insarennes/nperier/minichamo/language/assignement/param/VarParam.java
+ 4
− 0
View file @ a31d2647
......@@ -19,6 +19,10 @@ public class VarParam extends AssignementParam {
return List.of(varname);
}
public String getVar() {
return varname;
}
@Override
public Type getType() {
return type;
......
src/main/java/fr/insarennes/nperier/minichamo/language/definition/FunctionDef.java
+ 21
− 5
View file @ a31d2647
package fr.insarennes.nperier.minichamo.language.definition;
import fr.insarennes.nperier.minichamo.language.assignement.param.AssignementParam;
import fr.insarennes.nperier.minichamo.language.typing.FunctionType;
import fr.insarennes.nperier.minichamo.language.assignement.param.VarParam;
import fr.insarennes.nperier.minichamo.language.typing.GenericType;
import fr.insarennes.nperier.minichamo.language.typing.Type;
import fr.insarennes.nperier.minichamo.parsing.Context;
import fr.insarennes.nperier.minichamo.utils.SymbolPosition;
......@@ -10,7 +11,8 @@ import java.util.List;
public class FunctionDef extends VariableDef {
private final List<AssignementParam> params;
private final List<VarParam> params;
private Type returnType;
public FunctionDef(String n, Context c, SymbolPosition p, boolean isRecursive) {
super(n, c, p);
......@@ -18,15 +20,29 @@ public class FunctionDef extends VariableDef {
if(isRecursive) {
ctx.addVariable(this);
}
returnType = GenericType.forNumber(0);
}
public FunctionDef addParam(AssignementParam p) {
public FunctionDef addParam(VarParam p) {
params.add(p);
return this;
}
public int getNbParams() {
return params.size();
return params.size();
}
public List<VarParam> getParams() {
return params;
}
public Type getReturnType() {
return returnType;
}
public FunctionDef setReturnType(Type t) {
returnType = t;
return this;
}
@Override
......
src/main/java/fr/insarennes/nperier/minichamo/parsing/DefinitionParser.java
+ 33
− 28
View file @ a31d2647
package fr.insarennes.nperier.minichamo.parsing;
import fr.insarennes.nperier.minichamo.language.assignement.param.VarParam;
import fr.insarennes.nperier.minichamo.language.definition.FunctionDef;
import fr.insarennes.nperier.minichamo.language.definition.ValueDef;
import fr.insarennes.nperier.minichamo.language.definition.VariableDef;
import fr.insarennes.nperier.minichamo.language.assignement.param.AssignementParam;
import fr.insarennes.nperier.minichamo.language.assignement.param.NupleParam;
import fr.insarennes.nperier.minichamo.language.assignement.param.VarParam;
import fr.insarennes.nperier.minichamo.language.typing.BuiltinType;
import fr.insarennes.nperier.minichamo.language.typing.GenericType;
import fr.insarennes.nperier.minichamo.language.typing.Type;
......@@ -16,6 +14,11 @@ import fr.insarennes.nperier.minichamo.errors.ParsingException;
import fr.insarennes.nperier.minichamo.utils.SymbolPosition;
import fr.insarennes.nperier.minichamo.utils.TokenPeekIterator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class DefinitionParser {
public static VariableDef parse(TokenPeekIterator it, Context ctx) {
......@@ -30,22 +33,11 @@ public class DefinitionParser {
}
Type t = it.junkIf(TokenType.COLON) ? TypeParser.parse(it, ctx) : GenericType.forNumber(0);
return new ValueDef(name, ctx, pos, t);
//AssignementParam param = new VarParam(name, t);
//if(it.peekIs(TokenType.COMMA)) {
// param = parseNupleDef(it, ctx, new Counter(1), param);
//}
}
//if(it.peekIs(TokenType.LPAREN)) {
// Counter count = new Counter();
// AssignementParam param = parseInParen(it, ctx, count);
// if(it.peekIs(TokenType.COMMA)) {
// param = parseNupleDef(it, ctx, count, param);
// }
//}
throw new ParsingException("Expected variable definition", it.peek());
}
public static AssignementParam parseParam(TokenPeekIterator it, Context ctx, Counter count, boolean canDefineType) {
public static VarParam parseParam(TokenPeekIterator it, Context ctx, Counter count, boolean canDefineType) {
if(it.peekIs(TokenType.NAME)) {
String name = ((NameToken) it.next()).getName();
Type t;
......@@ -81,11 +73,24 @@ public class DefinitionParser {
if(res.getNbParams() == 0) {
throw new ParsingException("Expected parameters for function " + res.getName(), it.peek());
}
List<String> params = res.getParams().stream()
.map(VarParam::getVar)
.collect(Collectors.toList());
Set<String> uniq = new HashSet<>(params);
if(params.size() != uniq.size()) {
for(String s : uniq) {
params.remove(s);
}
if(params.size() == 1) {
throw new ParsingException("Duplicate parameter " + params.get(0) + " in function " + res.getName(), pos);
}
throw new ParsingException("Duplicate parameters in function " + res.getName(), pos);
}
return res;
}
public static AssignementParam parseInParen(TokenPeekIterator it, Context ctx, Counter count) {
AssignementParam res;
public static VarParam parseInParen(TokenPeekIterator it, Context ctx, Counter count) {
VarParam res;
if(it.junkIf(TokenType.RPAREN)) {
return new VarParam("()", BuiltinType.unit());
}
......@@ -103,20 +108,20 @@ public class DefinitionParser {
Type t = GenericType.forNumber(count.next());
res = new VarParam(name, t);
}
if(it.peekIs(TokenType.COMMA)) {
res = parseNupleDef(it, ctx, count, res);
}
// if(it.peekIs(TokenType.COMMA)) {
// res = parseNupleDef(it, ctx, count, res);
// }
it.expectJunk(TokenType.RPAREN);
return res;
}
public static AssignementParam parseNupleDef(TokenPeekIterator it, Context ctx, Counter count, AssignementParam first) {
NupleParam res = new NupleParam();
res.addParam(first);
while(it.junkIf(TokenType.COMMA)) {
res.addParam(parseParam(it, ctx, count, false));
}
return res;
}
// public static AssignementParam parseNupleDef(TokenPeekIterator it, Context ctx, Counter count, AssignementParam first) {
// NupleParam res = new NupleParam();
// res.addParam(first);
// while(it.junkIf(TokenType.COMMA)) {
// res.addParam(parseParam(it, ctx, count, false));
// }
// return res;
// }
}
src/test/java/fr/insarennes/nperier/minichamo/parsing/DefinitionParserTest.java
+ 36
− 13
View file @ a31d2647
package fr.insarennes.nperier.minichamo.parsing;
import fr.insarennes.nperier.minichamo.errors.ParsingException;
import fr.insarennes.nperier.minichamo.language.assignement.param.NupleParam;
import fr.insarennes.nperier.minichamo.language.assignement.param.VarParam;
import fr.insarennes.nperier.minichamo.language.definition.FunctionDef;
......@@ -88,24 +89,46 @@ public class DefinitionParserTest {
}
@Test
public void testNestedParamsFuncAssign() {
TokenPeekIterator it = new Lexer("let f (un, ((deux, trois), quatre));;").wrap();
public void testReturnTypeFunction() {
TokenPeekIterator it = new Lexer("let f uno (dos: int list) tres : string;;").wrap();
Assertions.assertTrue(it.junkIf(TokenType.LET));
NupleParam n1 = new NupleParam()
.addParam(new VarParam("deux", new GenericType("b")))
.addParam(new VarParam("trois", new GenericType("c")));
NupleParam n2 = new NupleParam()
.addParam(n1)
.addParam(new VarParam("quatre", new GenericType("d")));
NupleParam n3 = new NupleParam()
.addParam(new VarParam("un", new GenericType("a")))
.addParam(n2);
FunctionDef exp = new FunctionDef("f", ctx, SymbolPosition.begin(), false)
.addParam(n3);
.addParam(new VarParam("uno", new GenericType("a")))
.addParam(new VarParam("dos", BuiltinType.list(BuiltinType.integer())))
.addParam(new VarParam("tres", new GenericType("b")))
.setReturnType(BuiltinType.str());
VariableDef res = DefinitionParser.parse(it, ctx);
Assertions.assertEquals(exp, res);
Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
Assertions.assertFalse(it.hasNext());
Assertions.assertEquals(exp, res);
}
@Test
public void testDuplicateParameter() {
TokenPeekIterator it = new Lexer("let f a b c a;;").wrap();
Assertions.assertTrue(it.junkIf(TokenType.LET));
Assertions.assertThrows(ParsingException.class, () -> DefinitionParser.parse(it, ctx));
}
// @Test
// public void testNestedParamsFuncAssign() {
// TokenPeekIterator it = new Lexer("let f (un, ((deux, trois), quatre));;").wrap();
// Assertions.assertTrue(it.junkIf(TokenType.LET));
// NupleParam n1 = new NupleParam()
// .addParam(new VarParam("deux", new GenericType("b")))
// .addParam(new VarParam("trois", new GenericType("c")));
// NupleParam n2 = new NupleParam()
// .addParam(n1)
// .addParam(new VarParam("quatre", new GenericType("d")));
// NupleParam n3 = new NupleParam()
// .addParam(new VarParam("un", new GenericType("a")))
// .addParam(n2);
// FunctionDef exp = new FunctionDef("f", ctx, SymbolPosition.begin(), false)
// .addParam(n3);
// VariableDef res = DefinitionParser.parse(it, ctx);
// Assertions.assertEquals(exp, res);
// Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
// Assertions.assertFalse(it.hasNext());
// }
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment