pietervdvn/AspectedRouting
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rework output system: apply 'Tags', add many rewriting rules, add tests

Browse source
This commit is contained in:
Pieter Vander Vennet 2022-09-06 18:46:01 +02:00
parent 1f27a45037
commit a84bbceda2
42 changed files with 1384 additions and 424 deletions
Download patch file Download diff file Expand all files Collapse all files

48
AspectedRouting.Test/FunctionsTest.cs
View file

@ -54,7 +54,7 @@ public class FunctionsTest
{ "x", "y" } { "x", "y" }
}; };
var expr = new Apply(MustMatchJson(), new Constant(tagsAx)).Optimize(); var expr = new Apply(MustMatchJson(), new Constant(tagsAx)).Optimize(out _);
var result = expr.Evaluate(new Context()); var result = expr.Evaluate(new Context());
Assert.Equal("yes", result); Assert.Equal("yes", result);
} }
@ -67,7 +67,7 @@ public class FunctionsTest
{ "a", "b" } { "a", "b" }
}; };
var expr = new Apply(MustMatchJson(), new Constant(tagsAx)).Optimize(); var expr = new Apply(MustMatchJson(), new Constant(tagsAx)).Optimize(out var _);
var result = expr.Evaluate(new Context()); var result = expr.Evaluate(new Context());
Assert.Equal("no", result); Assert.Equal("no", result);
} }
@ -81,7 +81,7 @@ public class FunctionsTest
{ "x", "someRandomValue" } { "x", "someRandomValue" }
}; };
var expr = new Apply(MustMatchJson(), new Constant(tagsAx)).Optimize(); var expr = new Apply(MustMatchJson(), new Constant(tagsAx)).Optimize(out _);
var result = expr.Evaluate(new Context()); var result = expr.Evaluate(new Context());
Assert.Equal("no", result); Assert.Equal("no", result);
} }
@ -97,7 +97,7 @@ public class FunctionsTest
var resultT = ifExpr.Evaluate(c); var resultT = ifExpr.Evaluate(c);
Assert.Equal("thenResult", resultT); Assert.Equal("thenResult", resultT);
resultT = ifExpr.Optimize().Evaluate(c); resultT = ifExpr.Optimize(out _).Evaluate(c);
Assert.Equal("thenResult", resultT); Assert.Equal("thenResult", resultT);
} }
@ -123,7 +123,7 @@ public class FunctionsTest
{ {
var c = new Context(); var c = new Context();
var ifExpr = JsonParser.ParseExpression(c, IfDottedConditionJson); var ifExpr = JsonParser.ParseExpression(c, IfDottedConditionJson);
ifExpr = ifExpr.Optimize(); ifExpr = ifExpr.Optimize(out _);
var resultT = ifExpr.Evaluate(c, var resultT = ifExpr.Evaluate(c,
new Constant(Typs.String, "yes")); new Constant(Typs.String, "yes"));
var resultF = ifExpr.Evaluate(c, var resultF = ifExpr.Evaluate(c,
@ -393,8 +393,8 @@ public class FunctionsTest
var o = f.Evaluate(new Context(), tags0); var o = f.Evaluate(new Context(), tags0);
Assert.Equal(50.0, o); Assert.Equal(50.0, o);
} }
[Fact] [Fact]
public void ApplyFirstMatchOf_FirstMatchIsTaken_ResidentialDefault() public void ApplyFirstMatchOf_FirstMatchIsTaken_ResidentialDefault()
{ {
@ -407,7 +407,7 @@ public class FunctionsTest
var o = f.Evaluate(new Context(), tags0); var o = f.Evaluate(new Context(), tags0);
Assert.Equal(30, o); Assert.Equal(30, o);
} }
[Fact] [Fact]
public void ApplyFirstMatchOf_NoMatchIfFound_Null() public void ApplyFirstMatchOf_NoMatchIfFound_Null()
{ {
@ -444,4 +444,36 @@ public class FunctionsTest
); );
return Funcs.FirstOf.Apply(order, mapping); return Funcs.FirstOf.Apply(order, mapping);
} }
[Fact]
/**
* Regression test for a misbehaving ifDotted
*/
public void IfDotted_CorrectExpression()
{
var e = Funcs.IfDotted.Apply(
Funcs.Const.Apply(new Parameter("follow_restrictions")),
Funcs.Head.Apply( Funcs.StringStringToTags.Apply( new Mapping(new[] { "oneway" }, new[] { Funcs.Id }))),
Funcs.Const.Apply(new Constant("dont-care"))
);
var c = new Context();
c.AddParameter("follow_restrictions", "yes");
var tags = new Dictionary<string, string>();
tags["oneway"] = "with";
var r = e.Evaluate(c, new Constant(tags));
Assert.Equal("with", r);
var c0 = new Context();
c0.AddParameter("follow_restrictions", "no");
var r0 = e.Evaluate(c0, new Constant(tags));
Assert.Equal("dont-care", r0);
}
} }

151
AspectedRouting.Test/OptimizationsTests.cs Normal file
View file

@ -0,0 +1,151 @@
using AspectedRouting.IO.LuaSkeleton;
using AspectedRouting.Language;
using AspectedRouting.Language.Expression;
using AspectedRouting.Language.Functions;
using AspectedRouting.Language.Typ;
using Xunit;
namespace AspectedRouting.Test;
public class OptimizationsTests
{
[Fact]
public void AppliedListDot_Optimize_ListOfApplications()
{
var lit = new LuaLiteral(Typs.Nat, "tags");
var e0 = Funcs.ListDot.Apply(
new Constant(new[]
{
Funcs.Eq.Apply(new Constant(5)),
Funcs.Eq.Apply(new Constant(42))
}));
var e = e0.Apply(lit).SpecializeToSmallestType();
var x = e.Optimize(out var sc);
Assert.True(sc);
Assert.Equal(
new Constant(new[]
{
Funcs.Eq.Apply(new Constant(5)).Apply(lit),
Funcs.Eq.Apply(new Constant(42)).Apply(lit)
}).SpecializeToSmallestType().ToString(), x.ToString());
}
[Fact]
public void AdvancedApplied_Optimized_ListOfAppliedValues()
{
var legal_access_be = new FunctionCall("$legal_access_be", new Curry(Typs.Tags, Typs.String));
var legal_access_pedestrian = new FunctionCall("$pedestrian.legal_access", new Curry(Typs.Tags, Typs.String));
var tags = new LuaLiteral(Typs.Tags, "tags");
var e = new Apply( // string
Funcs.Head,
new Apply( // list (string)
new Apply( // tags -> list (string)
Funcs.ListDot,
new Constant(new[]
{
legal_access_be,
legal_access_pedestrian
})),
tags));
var eOpt = e.Optimize(out var sc);
Assert.True(sc);
Assert.Equal(
Funcs.Head.Apply(new Constant(
new[]
{
legal_access_be.Apply(tags),
legal_access_pedestrian.Apply(tags)
}
)).ToString(),
eOpt.ToString()
);
}
[Fact]
public void advancedExpr_Optimize_Works()
{
var e = new Apply( // double
new Apply( // tags -> double
new Apply( // (tags -> double) -> tags -> doubleTag
Funcs.Default,
new Constant(0)),
new Apply( // tags -> double
new Apply( // (tags -> list (double)) -> tags -> double
Funcs.Dot,
Funcs.Head),
new Apply( // tags -> list (double)
Funcs.StringStringToTags,
new Mapping(
new[]
{
"access"
},
new[]
{
new Mapping(
new[]
{
"private",
"destination",
"permissive"
},
new[]
{
new Constant(-500), new Constant(-3), new Constant(-1)
}
)
}
)))),
new LuaLiteral(Typs.Tags, "tags"));
var eOpt = e.Optimize(out var sc);
Assert.True(sc);
Assert.NotEmpty(eOpt.Types);
}
[Fact]
public void optimizeListdotAway()
{
var tagsToStr = new Curry(Typs.Tags, Typs.PDouble);
var e = new Apply( // pdouble
new Apply( // tags -> pdouble
Funcs.Id,
new Apply( // tags -> pdouble
new Apply( // (tags -> list (pdouble)) -> tags -> pdouble
Funcs.Dot,
Funcs.Min),
new Apply( // tags -> list (pdouble)
Funcs.ListDot,
new Constant(new IExpression[]
{
new FunctionCall("$legal_maxspeed_be", tagsToStr),
new FunctionCall("$car.practical_max_speed", tagsToStr),
new Apply( // tags -> pdouble
Funcs.Const,
new Parameter("#maxspeed"))
})))),
new LuaLiteral(Typs.Tags, "tags"));
var opt = e.SpecializeToSmallestType().Optimize(out var sc);
Assert.True(sc);
}
[Fact]
public void Regression_ShouldOptimize()
{
var e = new Apply( // nat
new Apply( // tags -> nat
new Apply( // nat -> tags -> nat
new Apply( // (nat -> tags -> nat) -> nat -> tags -> nat
Funcs.ConstRight,
Funcs.Id),
Funcs.Const),
new LuaLiteral(Typs.PDouble, "distance")),
new LuaLiteral(Typs.Tags, "tags")).SpecializeToSmallestType();
var opt = e.Optimize(out var sc);
Assert.True(sc);
}
}

52
AspectedRouting.Test/RegressionTest.cs Normal file
View file

@ -0,0 +1,52 @@
using System.Collections;
using System.Collections.Generic;
using System.Text.Json;
using AspectedRouting.IO.jsonParser;
using AspectedRouting.Language;
using AspectedRouting.Language.Expression;
using AspectedRouting.Language.Functions;
using AspectedRouting.Language.Typ;
using Xunit;
namespace AspectedRouting.Test;
public class RegressionTest
{
[Fact]
public void IfDotted_ShouldBeParsed()
{
var carOneway = Funcs.Const.Apply(new Constant("result of car.oneway")).Specialize(new Curry(
Typs.Tags, Typs.String));
var doc = JsonDocument.Parse("{\"oneway\":{\"$ifdotted\":{\"$const\": \"#follow_restrictions\"},\"then\": \"$car.oneway\",\"else\": {\"$const\": \"both-ignored-restrictions\"}}}");
var parsingContext = new Context();
parsingContext .AddFunction("car.oneway", new AspectMetadata(
carOneway, "car.oneway","oneway function", "test", "with|against|both",
"N/A", false
));
parsingContext.AddParameter("follow_restrictions","no");
var aspect = JsonParser.ParseProfileProperty(doc.RootElement,parsingContext, "oneway");
var oneway = new Dictionary<string, string>();
var c = new Context();
c .AddFunction("car.oneway", new AspectMetadata(
carOneway, "car.oneway","oneway function", "test", "with|against|both",
"N/A", false
));
c.AddParameter("follow_restrictions","yes");
var result = aspect.Run(c, oneway);
Assert.Equal("result of car.oneway", result);
var c0 = new Context();
c0.AddFunction("car.oneway", new AspectMetadata(
carOneway, "car.oneway","oneway function", "test", "with|against|both",
"N/A", false
));
c0.AddParameter("follow_restrictions","no");
var result0 = aspect.Run(c0, oneway);
Assert.Equal("both-ignored-restrictions", result0);
}
}

159
AspectedRouting.Test/Snippets/SnippetTests.cs
View file

@ -7,84 +7,91 @@ using AspectedRouting.Language.Functions;
using AspectedRouting.Language.Typ; using AspectedRouting.Language.Typ;
using Xunit; using Xunit;
namespace AspectedRouting.Test.Snippets namespace AspectedRouting.Test.Snippets;
public class SnippetTests
{ {
public class SnippetTests [Fact]
public void DefaultSnippet_SimpleDefault_GetsLua()
{ {
[Fact] var gen = new DefaultSnippet();
public void DefaultSnippet_SimpleDefault_GetsLua() var lua = new LuaSkeleton(new Context(), true);
var code = gen.Convert(lua, "result", new List<IExpression>
{ {
var gen = new DefaultSnippet(); new Constant("the_default_value"),
var lua = new LuaSkeleton(new Context(), true); Funcs.Id,
var code = gen.Convert(lua, "result", new List<IExpression> { new Constant("value")
new Constant("the_default_value"), });
Funcs.Id, Assert.Contains("if (result == nil) then\n result = \"the_default_value\"", code);
new Constant("value")
});
Assert.Contains("if (result == nil) then\n result = \"the_default_value\"", code);
}
[Fact]
public void FirstOfSnippet_SimpleFirstOf_GetLua()
{
var gen = new FirstMatchOfSnippet();
var lua = new LuaSkeleton(new Context(), true);
// FirstMatchOf: [a] -> (Tags -> [a]) -> Tags -> a
// Order: [string]
var order = new Constant(new List<IExpression> {
new Constant("bicycle"),
new Constant("access")
});
// Func: (Tags -> [a])
var func = new Apply(
Funcs.StringStringToTags,
new Mapping(
new[] { "bicycle", "access" },
new IExpression[] {
Funcs.Id,
Funcs.Id
}
)
);
var tags = new LuaLiteral(new[] { Typs.Tags }, "tags");
var code = gen.Convert(lua, "result",
new List<IExpression> {
order,
func,
tags
}
);
// First the more general ones!
Assert.Equal(
"if (tags[\"access\"] ~= nil) then\n result = tags[\"access\"]\n \nend\nif (tags[\"bicycle\"] ~= nil) then\n result = tags[\"bicycle\"]\n \nend\n",
code);
}
[Fact]
public void SimpleMappingSnippet_SimpleMapping_GeneratesLua()
{
var mapping = new Mapping(
new[] { "1", "-1" },
new IExpression[] {
new Constant("with"),
new Constant("against")
}
);
var gen = new SimpleMappingSnippet(mapping);
var code = gen.Convert(new LuaSkeleton(new Context(), true), "result", new List<IExpression> {
new LuaLiteral(Typs.String, "tags.oneway")
});
var expected =
"local v\nv = tags.oneway\n\nif (v == \"1\") then\n result = \"with\"\nelseif (v == \"-1\") then\n result = \"against\"\nend";
Assert.Equal(expected, code);
}
} }
[Fact]
public void FirstOfSnippet_SimpleFirstOf_GetLua()
{
var gen = new FirstMatchOfSnippet();
var lua = new LuaSkeleton(new Context(), true);
// FirstMatchOf: [a] -> (Tags -> [a]) -> Tags -> a
// Order: [string]
var order = new Constant(new List<IExpression>
{
new Constant("bicycle"),
new Constant("access")
});
// Func: (Tags -> [a])
var func = new Apply(
Funcs.StringStringToTags,
new Mapping(
new[] { "bicycle", "access" },
new IExpression[]
{
Funcs.Id,
Funcs.Id
}
)
);
var tags = new LuaLiteral(new[] { Typs.Tags }, "tags");
var code = gen.Convert(lua, "result",
new List<IExpression>
{
order,
func,
tags
}
);
// First the more general ones!
Assert.Equal(
"if (tags[\"access\"] ~= nil) then\n result = tags[\"access\"]\n \nend\nif (tags[\"bicycle\"] ~= nil) then\n result = tags[\"bicycle\"]\n \nend\n",
code);
}
[Fact]
public void SimpleMappingSnippet_SimpleMapping_GeneratesLua()
{
var mapping = new Mapping(
new[] { "1", "-1" },
new IExpression[]
{
new Constant("with"),
new Constant("against")
}
);
var gen = new SimpleMappingSnippet(mapping);
var code = gen.Convert(new LuaSkeleton(new Context(), true), "result", new List<IExpression>
{
new LuaLiteral(Typs.String, "tags.oneway")
});
var expected =
"local v\nv = tags.oneway\n\nif (v == \"1\") then\n result = \"with\"\nelseif (v == \"-1\") then\n result = \"against\"\nend";
Assert.Equal(expected, code);
}
} }

26
AspectedRouting/IO/LuaSkeleton/LuaLiteral.cs
View file

@ -2,6 +2,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using AspectedRouting.Language; using AspectedRouting.Language;
using AspectedRouting.Language.Typ;
using Type = AspectedRouting.Language.Typ.Type; using Type = AspectedRouting.Language.Typ.Type;
namespace AspectedRouting.IO.LuaSkeleton namespace AspectedRouting.IO.LuaSkeleton
@ -40,14 +41,35 @@ namespace AspectedRouting.IO.LuaSkeleton
return null; return null;
} }
public IExpression Optimize() public IExpression Optimize(out bool somethingChanged)
{ {
somethingChanged = false;
return this; return this;
} }
public void Visit(Func<IExpression, bool> f) public void Visit(Func<IExpression, bool> f)
{ {
throw new NotImplementedException(); f(this);
}
public bool Equals(IExpression other)
{
if (other is LuaLiteral ll)
{
return ll.Lua.Equals(this.Lua);
}
return false;
}
public string Repr()
{
if (this.Types.Count() == 1 && this.Types.First() == Typs.Tags)
{
return $"new LuaLiteral(Typs.Tags, \"{this.Lua}\")";
}
return $"new LuaLiteral(\"{this.Lua}\")";
} }
} }
} }

66
AspectedRouting/IO/LuaSkeleton/LuaSkeleton.Expressions.cs
View file

@ -1,5 +1,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Dynamic;
using System.Linq; using System.Linq;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using AspectedRouting.IO.itinero1; using AspectedRouting.IO.itinero1;
@ -13,6 +14,12 @@ namespace AspectedRouting.IO.LuaSkeleton
{ {
public partial class LuaSkeleton public partial class LuaSkeleton
{ {
internal string ToLuaWithTags(IExpression bare)
{
var opt = bare.Apply(new LuaLiteral(Typs.Tags, "tags")).SpecializeToSmallestType().Optimize(out _);
return this.ToLua(opt);
}
internal string ToLua(IExpression bare, string key = "nil", bool forceFirstArgInDot = false) internal string ToLua(IExpression bare, string key = "nil", bool forceFirstArgInDot = false)
{ {
var collectedMapping = new List<IExpression>(); var collectedMapping = new List<IExpression>();
@ -57,36 +64,29 @@ namespace AspectedRouting.IO.LuaSkeleton
return "memberOf(funcName, parameters, tags, result)"; return "memberOf(funcName, parameters, tags, result)";
} }
{
var collectedList = new List<IExpression>(); var name = new List<string>();
var func = new List<IExpression>(); var arg = new List<IExpression>();
if ( if (UnApply(
UnApply( IsFunctionCall(name),
UnApply(IsFunc(Funcs.Dot), Assign(func)), Assign(arg)
UnApply(IsFunc(Funcs.ListDot), ).Invoke(bare))
Assign(collectedList))).Invoke(bare)) { {
var exprs = (IEnumerable<IExpression>) ((Constant) collectedList.First()).Evaluate(_context); var called = _context.DefinedFunctions[name.First()];
var luaExprs = new List<string>(); if (called.ProfileInternal) {
var funcName = func.First().ToString().TrimStart('$'); return called.Name;
AddDep(funcName);
foreach (var expr in exprs) {
var c = new List<IExpression>();
if (UnApply(IsFunc(Funcs.Const), Assign(c)).Invoke(expr)) {
luaExprs.Add(ToLua(c.First(), key));
continue;
} }
if (expr.Types.First() is Curry curry AddDependenciesFor(called);
&& curry.ArgType.Equals(Typs.Tags)) { AddFunction(called);
var lua = ToLua(expr, key); var usesParams = called.ExpressionImplementation.UsedParameters().Any();
luaExprs.Add(lua); if (usesParams)
{
return $"{name.First().Replace(".","_")}({ToLua(arg.First())}, parameters)";
} }
return $"{name.First().Replace(".","_")}({ToLua(arg.First())})";
} }
return "\n " + funcName + "({\n " + string.Join(",\n ", luaExprs) +
"\n })";
} }
collectedMapping.Clear(); collectedMapping.Clear();
var dottedFunction = new List<IExpression>(); var dottedFunction = new List<IExpression>();
dottedFunction.Clear(); dottedFunction.Clear();
@ -116,7 +116,7 @@ namespace AspectedRouting.IO.LuaSkeleton
bare.Types.First() is Curry curr && bare.Types.First() is Curry curr &&
curr.ArgType.Equals(Typs.String)) { curr.ArgType.Equals(Typs.String)) {
var applied = new Apply(bare, new Constant(curr.ArgType, ("tags", "\"" + key + "\""))); var applied = new Apply(bare, new Constant(curr.ArgType, ("tags", "\"" + key + "\"")));
return ToLua(applied.Optimize(), key); return ToLua(applied.Optimize(out _), key);
} }
@ -139,7 +139,13 @@ namespace AspectedRouting.IO.LuaSkeleton
} }
if (baseFunc.Name.Equals(Funcs.Dot.Name)) { if (baseFunc.Name.Equals(Funcs.Dot.Name)) {
if (args.Count == 1 || forceFirstArgInDot) { if (args.Count == 1 )
{
return ToLua(args[0]);
}
if (forceFirstArgInDot)
{
return ToLua(args[0]); return ToLua(args[0]);
} }
@ -173,7 +179,7 @@ namespace AspectedRouting.IO.LuaSkeleton
AddDependenciesFor(called); AddDependenciesFor(called);
AddFunction(called); AddFunction(called);
return $"{fc.CalledFunctionName.AsLuaIdentifier()}(parameters, tags, result)"; return $"{fc.CalledFunctionName.AsLuaIdentifier()}(tags, parameters)";
case Constant c: case Constant c:
return ConstantToLua(c); return ConstantToLua(c);
case Mapping m: case Mapping m:
@ -241,12 +247,12 @@ namespace AspectedRouting.IO.LuaSkeleton
/// <returns></returns> /// <returns></returns>
private string ConstantToLua(Constant c) private string ConstantToLua(Constant c)
{ {
var o = c.Evaluate(_context); var o = c.Get();
switch (o) { switch (o) {
case LuaLiteral lua: case LuaLiteral lua:
return lua.Lua; return lua.Lua;
case IExpression e: case IExpression e:
return ConstantToLua(new Constant(e.Types.First(), e.Evaluate(null))); return ToLua(e);
case int i: case int i:
return "" + i; return "" + i;
case double d: case double d:

18
AspectedRouting/IO/LuaSkeleton/LuaSkeleton.Function.cs
View file

@ -1,3 +1,4 @@
using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using AspectedRouting.IO.itinero1; using AspectedRouting.IO.itinero1;
@ -35,17 +36,21 @@ namespace AspectedRouting.IO.LuaSkeleton
return true; return true;
}); });
var expression = meta.ExpressionImplementation; var expression = Funcs.Either(Funcs.Id, Funcs.Const, meta.ExpressionImplementation)
.Apply(new LuaLiteral(Typs.Tags, "tags"))
.PruneTypes(t => !(t is Curry))
.SpecializeToSmallestType()
.Optimize(out _);
if (!expression.Types.Any())
{
throw new Exception("Could not optimize expression with applied tags");
}
var ctx = Context; var ctx = Context;
_context = _context.WithAspectName(meta.Name); _context = _context.WithAspectName(meta.Name);
var body = ""; var body = "";
if (_useSnippets) { if (_useSnippets) {
if (expression.Types.First() is Curry c) {
expression = expression.Apply(new LuaLiteral(Typs.Tags, "tags"));
}
body = Utils.Lines( body = Utils.Lines(
" local r = nil", " local r = nil",
" " + Snippets.Convert(this, "r", expression).Indent(), " " + Snippets.Convert(this, "r", expression).Indent(),
@ -56,7 +61,6 @@ namespace AspectedRouting.IO.LuaSkeleton
body = " return " + ToLua(expression); body = " return " + ToLua(expression);
} }
var impl = Utils.Lines( var impl = Utils.Lines(
"--[[", "--[[",
meta.Description, meta.Description,
@ -68,7 +72,7 @@ namespace AspectedRouting.IO.LuaSkeleton
"Number of combintations: " + numberOfCombinations, "Number of combintations: " + numberOfCombinations,
"Returns values: ", "Returns values: ",
"]]", "]]",
"function " + meta.Name.AsLuaIdentifier() + "(parameters, tags, result)" + funcNameDeclaration, "function " + meta.Name.AsLuaIdentifier() + "(tags, parameters)" + funcNameDeclaration,
body, body,
"end" "end"
); );

1
AspectedRouting/IO/LuaSkeleton/LuaSkeleton.cs
View file

@ -43,6 +43,7 @@ namespace AspectedRouting.IO.LuaSkeleton
internal void AddDep(string name) internal void AddDep(string name)
{ {
if (name.StartsWith("mapping")) { if (name.StartsWith("mapping")) {
Console.Error.WriteLine(">>>");
throw new Exception("A mapping was added as dependency - this is a bug"); throw new Exception("A mapping was added as dependency - this is a bug");
} }

2
AspectedRouting/IO/LuaSnippets/FirstMatchOfSnippet.cs
View file

@ -63,7 +63,7 @@ namespace AspectedRouting.IO.LuaSnippets
result += "end\n"; result += "end\n";
// note: we do not do an 'elseif' as we have to fallthrough // note: we do not do an 'elseif' as we have to fallthrough
if (result.Contains("tags[\"nil\"]")) { if (result.Contains("tags[\"nil\"]")) {
Console.WriteLine("EUHM"); Console.WriteLine("Warning: FirstMatchOf has a 'nil' in the indexes due to expression "+t.ToString());
} }
} }

2
AspectedRouting/IO/LuaSnippets/IfThenElseDottedSnippet.cs
View file

@ -11,7 +11,7 @@ namespace AspectedRouting.IO.LuaSnippets
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List<IExpression> args) public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List<IExpression> args)
{ {
var fCond = args[0].Optimize(); var fCond = args[0].Optimize(out _);
var fValue = args[1]; var fValue = args[1];
IExpression fElse = null; IExpression fElse = null;
var arg = args[2]; var arg = args[2];

57
AspectedRouting/IO/LuaSnippets/IfThenElseSnippet.cs
View file

@ -1,7 +1,9 @@
using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using AspectedRouting.Language; using AspectedRouting.Language;
using AspectedRouting.Language.Typ; using AspectedRouting.Language.Typ;
using static AspectedRouting.Language.Deconstruct;
namespace AspectedRouting.IO.LuaSnippets namespace AspectedRouting.IO.LuaSnippets
{ {
@ -11,29 +13,56 @@ namespace AspectedRouting.IO.LuaSnippets
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List<IExpression> args) public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List<IExpression> args)
{ {
var cond = args[0].Optimize(); var cond = args[0].Optimize(out _);
var ifTrue = args[1]; var ifTrue = args[1];
IExpression ifElse = null; IExpression ifElse = null;
if (args.Count == 3) { if (args.Count == 3) {
ifElse = args[2]; ifElse = args[2];
} }
var c = lua.FreeVar("cond");
var result = "";
result += "local " + c+"\n";
var isString = cond.Types.First().Equals(Typs.String);
result += Snippets.Convert(lua, c, cond)+"\n";
result += $"if ( {c} or {c} == \"yes\" ) then \n";
result += " " + Snippets.Convert(lua, assignTo, ifTrue).Indent() ;
if (ifElse != null) { {
result += "else\n"; var fa = new List<IExpression>();
result += " " + Snippets.Convert(lua, assignTo, ifElse).Indent(); if (UnApply(
IsFunc(Funcs.IsNull),
Assign(fa)
).Invoke(cond))
{
if (fa.First().ToString() == ifElse.ToString())
{
var result = "";
// We calculate the value that we need
result += Snippets.Convert(lua,assignTo , ifElse)+"\n";
result += "if (" + assignTo + " == nil) then\n";
result += " " + Snippets.Convert(lua, assignTo, ifTrue).Indent();
result += "end\n";
return result;
}
throw new Exception("TODO optimize with default");
}
} }
result += "end\n"; {
return result; var c = lua.FreeVar("cond");
var result = "";
result += "local " + c+"\n";
var isString = cond.Types.First().Equals(Typs.String);
result += Snippets.Convert(lua, c, cond)+"\n";
result += $"if ( {c} or {c} == \"yes\" ) then \n";
result += " " + Snippets.Convert(lua, assignTo, ifTrue).Indent() ;
if (ifElse != null) {
result += "else\n";
result += " " + Snippets.Convert(lua, assignTo, ifElse).Indent();
}
result += "end\n";
return result;
}
} }
} }
} }

211
AspectedRouting/IO/LuaSnippets/ListFoldingSnippet.cs
View file

@ -21,99 +21,150 @@ namespace AspectedRouting.IO.LuaSnippets
public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List<IExpression> args) public override string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, List<IExpression> args)
{ {
// Multiply multiplies a list of values - we thus have to handle _each_ arg // Multiply multiplies a list of values - we thus have to handle _each_ arg
// Note: we get a single argument which is an expression resulting in a list of values // Note: we get a single argument which is an expression resulting in a list of values
var listToMultiply = args[0];
var mappings = new List<Mapping>();
var arg = new List<IExpression>();
if (UnApply(UnApply(
IsFunc(Funcs.StringStringToTags),
IsMapping(mappings)),
Assign(arg)
).Invoke(listToMultiply)) {
var mapping = mappings.First();
var result = assignTo + " = " + _neutralValue + "\n"; {
var mappingArg = arg.First(); var mappings = new List<Mapping>();
if (!Equals(mappingArg.Types.First(), Typs.Tags)) { var arg = new List<IExpression>();
return null; if (args.Count == 1 && UnApply(UnApply(
} IsFunc(Funcs.StringStringToTags),
IsMapping(mappings)),
Assign(arg)
).Invoke(args[0]))
{
var mapping = mappings.First();
string tags; var result = assignTo + " = " + _neutralValue + "\n";
if (mappingArg is LuaLiteral literal) { var mappingArg = arg.First();
tags = literal.Lua; if (!Equals(mappingArg.Types.First(), Typs.Tags))
} {
else { return null;
tags = lua.FreeVar("tags");
result += "local " + tags + " = nil\n";
result += Snippets.Convert(lua, tags, mappingArg);
}
var m = lua.FreeVar("m");
result += " local " + m + " = nil\n";
foreach (var (key, func) in mapping.StringToResultFunctions) {
result += "if (" + tags + "[\"" + key + "\"] ~= nil) then\n";
result += m + " = nil\n";
result += " " +
Snippets.Convert(lua, m,
func.Apply(new LuaLiteral(Typs.String, tags + "[\"" + key + "\"]"))).Indent() + "\n";
result += "\n\n if (" + m + " ~= nil) then\n " +
Combine(assignTo, m) +
"\n end\n";
result += "end\n";
}
return result;
}
var listDotArgs = new List<IExpression>();
if (UnApply(
UnApply(IsFunc(Funcs.ListDot),
Assign(listDotArgs)),
Assign(arg)
).Invoke(listToMultiply)) {
var listDotArg = arg.First();
if (!(listDotArgs.First().Evaluate(lua.Context) is List<IExpression> functionsToApply)) {
return null;
}
var result = " " + assignTo + " = " + _neutralValue + "\n";
string tags;
if (listDotArg is LuaLiteral literal) {
tags = literal.Lua;
}
else {
tags = lua.FreeVar("tags");
result += " local " + tags + "\n";
result += Snippets.Convert(lua, tags, listDotArg);
}
var m = lua.FreeVar("m");
result += " local " + m + "\n";
foreach (var func in functionsToApply) {
result += " " + m + " = nil\n";
var subMapping = ExtractSubMapping(func);
if (subMapping != null) {
var (key, f) = subMapping.Value;
var e = f.Apply(new LuaLiteral(Typs.String, tags + "[\"" + key + "\"]"));
e = e.Optimize();
result += Snippets.Convert(lua, m, e).Indent();
}
else {
result += Snippets.Convert(lua, m, func.Apply(new LuaLiteral(Typs.Tags, "tags")));
} }
string tags;
if (mappingArg is LuaLiteral literal)
{
tags = literal.Lua;
}
else
{
tags = lua.FreeVar("tags");
result += "local " + tags + " = nil\n";
result += Snippets.Convert(lua, tags, mappingArg);
}
result += "\n\n if (" + m + " ~= nil) then\n " + Combine(assignTo, m) + "\n end\n"; var m = lua.FreeVar("m");
result += " local " + m + " = nil\n";
foreach (var (key, func) in mapping.StringToResultFunctions)
{
result += "if (" + tags + "[\"" + key + "\"] ~= nil) then\n";
result += m + " = nil\n";
result += " " +
Snippets.Convert(lua, m,
func.Apply(new LuaLiteral(Typs.String, tags + "[\"" + key + "\"]"))).Indent() +
"\n";
result += "\n\n if (" + m + " ~= nil) then\n " +
Combine(assignTo, m) +
"\n end\n";
result += "end\n";
}
return result;
} }
}
{
// Print a 'listDot', assume 'tags' is the applied argument
var arg = new List<IExpression>();
var listDotArgs = new List<IExpression>();
if (args.Count == 1 && UnApply(
UnApply(IsFunc(Funcs.ListDot),
Assign(listDotArgs)),
Assign(arg)
).Invoke(args[0]))
{
var listDotArg = arg.First();
if (!(listDotArgs.First().Evaluate(lua.Context) is List<IExpression> functionsToApply))
{
return null;
}
var result = " " + assignTo + " = " + _neutralValue + "\n";
string tags;
if (listDotArg is LuaLiteral literal)
{
tags = literal.Lua;
}
else
{
tags = lua.FreeVar("tags");
result += " local " + tags + "\n";
result += Snippets.Convert(lua, tags, listDotArg);
}
var m = lua.FreeVar("m");
result += " local " + m + "\n";
foreach (var func in functionsToApply)
{
result += " " + m + " = nil\n";
var subMapping = ExtractSubMapping(func);
if (subMapping != null)
{
var (key, f) = subMapping.Value;
var e = f.Apply(new LuaLiteral(Typs.String, tags + "[\"" + key + "\"]"));
e = e.Optimize(out _);
result += Snippets.Convert(lua, m, e).Indent();
}
else
{
result += Snippets.Convert(lua, m, func.Apply(new LuaLiteral(Typs.Tags, "tags")));
}
return result; result += "\n\n if (" + m + " ~= nil) then\n " + Combine(assignTo, m) + "\n end\n";
}
return result;
}
}
{
var constantArgs = new List<Constant>();
if (args.Count == 1 && IsConstant(constantArgs).Invoke(args[0]))
{
if (!(constantArgs.First().Get() is List<IExpression> listItems))
{
return null;
}
var result = " " + assignTo + " = " + _neutralValue + "\n";
var m = lua.FreeVar("m");
result += " local " + m + "\n";
foreach (var listItem in listItems)
{
result += " " + m + " = nil\n";
result += Snippets.Convert(lua, m, listItem).Indent();
result += "\n\n if (" + m + " ~= nil) then\n " + Combine(assignTo, m) + "\n end\n";
}
return result;
}
} }
Console.Error.WriteLine("ListFoldingSnippet encountered an unsupported expression");
throw new NotImplementedException(); throw new NotImplementedException();
} }

2
AspectedRouting/IO/LuaSnippets/Snippets.cs
View file

@ -33,7 +33,7 @@ namespace AspectedRouting.IO.LuaSnippets
public static string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, IExpression e) public static string Convert(LuaSkeleton.LuaSkeleton lua, string assignTo, IExpression e)
{ {
var opt = e.Optimize(); var opt = e.Optimize(out _);
// Note that optimization might optimize to a _subtype_ of the original expresion - which is fine! // Note that optimization might optimize to a _subtype_ of the original expresion - which is fine!
var origType = e.Types.First(); var origType = e.Types.First();
var optType = opt.Types.First(); var optType = opt.Types.First();

29
AspectedRouting/IO/itinero1/LuaPrinter1.MainFunction.cs
View file

@ -1,3 +1,4 @@
using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using AspectedRouting.IO.LuaSkeleton; using AspectedRouting.IO.LuaSkeleton;
@ -14,9 +15,9 @@ namespace AspectedRouting.IO.itinero1
private string GenerateMainProfileFunction() private string GenerateMainProfileFunction()
{ {
var access = _skeleton.ToLua(_profile.Access); var access = _skeleton.ToLuaWithTags(_profile.Access);
var oneway = _skeleton.ToLua(_profile.Oneway); var oneway = _skeleton.ToLuaWithTags(_profile.Oneway);
var speed = _skeleton.ToLua(_profile.Speed); var speed = _skeleton.ToLuaWithTags(_profile.Speed);
var impl = string.Join("\n", var impl = string.Join("\n",
"", "",
@ -58,13 +59,16 @@ namespace AspectedRouting.IO.itinero1
var paramInLua = _skeleton.ToLua(new Parameter(parameterName)); var paramInLua = _skeleton.ToLua(new Parameter(parameterName));
var exprInLua = _skeleton.ToLua(expression.Optimize(), forceFirstArgInDot: true); var expr = Funcs.Either(Funcs.Id, Funcs.Const, expression).Apply(new LuaLiteral(Typs.Tags, "tags"))
var resultTypes = expression.Types.Select(t => t.Uncurry().Last()); .SpecializeToSmallestType()
if (resultTypes.Any(t => t.Name.Equals(Typs.Bool.Name))) .PruneTypes(t => !(t is Curry))
.Optimize(out _);
if (expr.Types.Any(t => t.Name.Equals(Typs.Bool.Name)))
{ {
_skeleton. AddDep("parse"); expr = Funcs.Parse.Apply(expr).SpecializeToSmallestType();
exprInLua = "parse(" + exprInLua + ")";
} }
var exprInLua = _skeleton.ToLua(expr);
impl += "\n " + string.Join("\n ", impl += "\n " + string.Join("\n ",
$"if({paramInLua} ~= 0) then", $"if({paramInLua} ~= 0) then",
@ -108,9 +112,15 @@ namespace AspectedRouting.IO.itinero1
var functionName = referenceName.AsLuaIdentifier(); var functionName = referenceName.AsLuaIdentifier();
behaviourParameters.TryGetValue("description", out var description); behaviourParameters.TryGetValue("description", out var description);
_skeleton.AddDep("copy_tags");
var usedkeys = _profile.AllExpressionsFor(behaviourName, _context)
.PossibleTagsRecursive(_context)
.Select(t => "\""+ t.Key+"\"")
.ToHashSet();
_skeleton.AddDep("remove_relation_prefix"); _skeleton.AddDep("remove_relation_prefix");
var impl = string.Join("\n", var impl = string.Join("\n",
"", "behaviour_"+functionName+"_used_keys = create_set({"+ string.Join(", " , usedkeys) + "})",
"--[[", "--[[",
description, description,
"]]", "]]",
@ -124,6 +134,7 @@ namespace AspectedRouting.IO.itinero1
impl += _parameterPrinter.DeclareParametersFor(behaviourParameters); impl += _parameterPrinter.DeclareParametersFor(behaviourParameters);
impl += " " + _profile.Name + "(parameters, tags, result)\n"; impl += " " + _profile.Name + "(parameters, tags, result)\n";
impl += " copy_tags(tags, result.attributes_to_keep, behaviour_" + functionName + "_used_keys)\n";
impl += "end\n"; impl += "end\n";
return (functionName, impl); return (functionName, impl);
} }

4
AspectedRouting/IO/itinero1/LuaPrinter1.RelationPreprocessor.cs
View file

@ -57,7 +57,7 @@ namespace AspectedRouting.IO.itinero1
func.Add(""); func.Add("");
func.Add(" subresult.attributes_to_keep = {}"); func.Add(" subresult.attributes_to_keep = {}");
func.Add(" parameters = default_parameters()"); func.Add(" parameters = default_parameters()");
func.Add($" matched = {preProcName}(parameters, relation_tags, subresult)"); func.Add($" matched = {preProcName}(relation_tags, parameters)");
func.Add(" if (matched) then"); func.Add(" if (matched) then");
var tagKey = "_relation:" + calledInFunction.AsLuaIdentifier(); var tagKey = "_relation:" + calledInFunction.AsLuaIdentifier();
extraKeys.Add(tagKey); extraKeys.Add(tagKey);
@ -90,7 +90,7 @@ namespace AspectedRouting.IO.itinero1
func.Add(" parameters = default_parameters()"); func.Add(" parameters = default_parameters()");
func.Add(_parameterPrinter.DeclareParametersFor(parameters.Where(kv => usedParameters.Contains(kv.Key)) func.Add(_parameterPrinter.DeclareParametersFor(parameters.Where(kv => usedParameters.Contains(kv.Key))
.ToDictionary(kv => kv.Key, kv => kv.Value))); .ToDictionary(kv => kv.Key, kv => kv.Value)));
func.Add($" matched = {preProcName}(parameters, relation_tags, subresult)"); func.Add($" matched = {preProcName}(relation_tags, parameters)");
func.Add(" if (matched) then"); func.Add(" if (matched) then");
tagKey = "_relation:" + behaviourName.AsLuaIdentifier() + ":" + calledInFunction.AsLuaIdentifier(); tagKey = "_relation:" + behaviourName.AsLuaIdentifier() + ":" + calledInFunction.AsLuaIdentifier();
extraKeys.Add(tagKey); extraKeys.Add(tagKey);

19
AspectedRouting/IO/itinero1/LuaPrinter1.cs
View file

@ -27,18 +27,19 @@ namespace AspectedRouting.IO.itinero1
_aspectTestSuites = aspectTestSuites?.Where(suite => suite != null) _aspectTestSuites = aspectTestSuites?.Where(suite => suite != null)
?.Select(testSuite => testSuite.WithoutRelationTests())?.ToList(); ?.Select(testSuite => testSuite.WithoutRelationTests())?.ToList();
_profileTests = profileTests; _profileTests = profileTests;
_skeleton = new LuaSkeleton.LuaSkeleton(context, false); _skeleton = new LuaSkeleton.LuaSkeleton(context, true);
_parameterPrinter = new LuaParameterPrinter(profile, _skeleton); _parameterPrinter = new LuaParameterPrinter(profile, _skeleton);
} }
public string ToLua() public string ToLua()
{ {
_skeleton.AddDep("spoken_instructions"); _skeleton.AddDep("spoken_instructions");
var (membershipFunction, extraKeys) = GenerateMembershipPreprocessor(); var (membershipFunction, extraKeys) = GenerateMembershipPreprocessor();
var (profileOverview, behaviourFunctions) = GenerateProfileFunctions(); var (profileOverview, behaviourFunctions) = GenerateProfileFunctions();
var mainFunction = GenerateMainProfileFunction(); var mainFunction = GenerateMainProfileFunction();
var tests = new LuaTestPrinter(_skeleton, new List<string>{"unitTest","unitTestProfile"}).GenerateFullTestSuite(_profileTests, _aspectTestSuites); var tests = new LuaTestPrinter(_skeleton, new List<string> { "unitTest", "unitTestProfile" })
.GenerateFullTestSuite(_profileTests, _aspectTestSuites);
var keys = _profile.AllExpressions(_context).PossibleTags().Keys var keys = _profile.AllExpressions(_context).PossibleTags().Keys
@ -62,7 +63,15 @@ namespace AspectedRouting.IO.itinero1
"", "",
profileOverview, profileOverview,
"", "",
_parameterPrinter.GenerateDefaultParameters() _parameterPrinter.GenerateDefaultParameters(),
"",
"function create_set(list)",
" local set = {}",
" for _, l in ipairs(list) do " +
" set[l] = true" +
" end",
" return set",
"end"
}; };
@ -106,7 +115,7 @@ namespace AspectedRouting.IO.itinero1
var behaviourImplementations = new List<string>(); var behaviourImplementations = new List<string>();
foreach (var (behaviourName, behaviourParameters) in _profile.Behaviours) foreach (var (behaviourName, behaviourParameters) in _profile.Behaviours)
{ {
var (functionName, implementation ) = GenerateBehaviourFunction(behaviourName, behaviourParameters); var (functionName, implementation) = GenerateBehaviourFunction(behaviourName, behaviourParameters);
behaviourImplementations.Add(implementation); behaviourImplementations.Add(implementation);
profiles.Add( profiles.Add(
string.Join(",\n ", string.Join(",\n ",

34
AspectedRouting/IO/itinero2/LuaPrinter2.MainFunction.cs
View file

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using AspectedRouting.IO.LuaSkeleton;
using AspectedRouting.Language; using AspectedRouting.Language;
using AspectedRouting.Language.Typ; using AspectedRouting.Language.Typ;
@ -39,23 +40,22 @@ namespace AspectedRouting.IO.itinero2
// The expression might still have multiple typings, // The expression might still have multiple typings,
// which take inputs different from 'Tags', so we specialize the expr first // which take inputs different from 'Tags', so we specialize the expr first
var exprSpecialized = expr; var appliedExpr = Funcs.Either(Funcs.Id, Funcs.Const, expr)
var resultType = expr.Types.First(); .Apply(new LuaLiteral(Typs.Tags, "tags").SpecializeToSmallestType())
if (exprSpecialized.Types.Count() >=2) { .PruneTypes(tp => !(tp is Curry));
exprSpecialized = expr.Specialize(new Curry(Typs.Tags, new Var("a"))); var exprSpecialized = appliedExpr.Optimize(out _);
if (exprSpecialized == null) {
throw new Exception("Could not specialize expression to type tags -> $a"); if (exprSpecialized.Types.First().Equals(Typs.Bool) || exprSpecialized.Types.First().Equals(Typs.String))
} {
resultType = (exprSpecialized.Types.First() as Curry).ResultType; _skeleton.AddDep("parse");
exprSpecialized = Funcs.Parse.Apply(exprSpecialized);
} }
var exprInLua = _skeleton.ToLua(exprSpecialized); var exprInLua = _skeleton.ToLua(exprSpecialized);
if (resultType.Equals(Typs.Bool) || resultType.Equals(Typs.String)) if (exprInLua.Contains("constRight") || exprInLua.Contains("firstArg"))
{ {
_skeleton.AddDep("parse"); throw new Exception("Not optimized properly:" + exprSpecialized.Repr());
exprInLua = "parse(" + exprInLua + ")";
} }
aspects.Add(weight + " * " + exprInLua); aspects.Add(weight + " * " + exprInLua);
} }
@ -126,7 +126,7 @@ namespace AspectedRouting.IO.itinero2
" local parameters = default_parameters()", " local parameters = default_parameters()",
_parameterPrinter.DeclareParametersFor(parameters), _parameterPrinter.DeclareParametersFor(parameters),
"", "",
" local oneway = " + _skeleton.ToLua(_profile.Oneway), " local oneway = " + _skeleton.ToLuaWithTags(_profile.Oneway).Indent(),
" tags.oneway = oneway", " tags.oneway = oneway",
" -- An aspect describing oneway should give either 'both', 'against' or 'width'", " -- An aspect describing oneway should give either 'both', 'against' or 'width'",
@ -134,7 +134,7 @@ namespace AspectedRouting.IO.itinero2
"", "",
" -- forward calculation. We set the meta tag '_direction' to 'width' to indicate that we are going forward. The other functions will pick this up", " -- forward calculation. We set the meta tag '_direction' to 'width' to indicate that we are going forward. The other functions will pick this up",
" tags[\"_direction\"] = \"with\"", " tags[\"_direction\"] = \"with\"",
" local access_forward = " + _skeleton.ToLua(_profile.Access), " local access_forward = " + _skeleton.ToLuaWithTags(_profile.Access).Indent(),
" if(oneway == \"against\") then", " if(oneway == \"against\") then",
" -- no 'oneway=both' or 'oneway=with', so we can only go back over this segment", " -- no 'oneway=both' or 'oneway=with', so we can only go back over this segment",
" -- we overwrite the 'access_forward'-value with no; whatever it was...", " -- we overwrite the 'access_forward'-value with no; whatever it was...",
@ -142,7 +142,7 @@ namespace AspectedRouting.IO.itinero2
" end", " end",
" if(access_forward ~= nil and access_forward ~= \"no\" and access_forward ~= false) then", " if(access_forward ~= nil and access_forward ~= \"no\" and access_forward ~= false) then",
" tags.access = access_forward -- might be relevant, e.g. for 'access=dismount' for bicycles", " tags.access = access_forward -- might be relevant, e.g. for 'access=dismount' for bicycles",
" result.forward_speed = " + _skeleton.ToLua(_profile.Speed).Indent(), " result.forward_speed = " + _skeleton.ToLuaWithTags(_profile.Speed).Indent(),
" tags.speed = result.forward_speed", " tags.speed = result.forward_speed",
" local priority = calculate_priority(parameters, tags, result, access_forward, oneway, result.forward_speed)", " local priority = calculate_priority(parameters, tags, result, access_forward, oneway, result.forward_speed)",
" if (priority <= 0) then", " if (priority <= 0) then",
@ -154,7 +154,7 @@ namespace AspectedRouting.IO.itinero2
"", "",
" -- backward calculation", " -- backward calculation",
" tags[\"_direction\"] = \"against\" -- indicate the backward direction to priority calculation", " tags[\"_direction\"] = \"against\" -- indicate the backward direction to priority calculation",
" local access_backward = " + _skeleton.ToLua(_profile.Access), " local access_backward = " + _skeleton.ToLuaWithTags(_profile.Access).Indent(),
" if(oneway == \"with\") then", " if(oneway == \"with\") then",
" -- no 'oneway=both' or 'oneway=against', so we can only go forward over this segment", " -- no 'oneway=both' or 'oneway=against', so we can only go forward over this segment",
" -- we overwrite the 'access_forward'-value with no; whatever it was...", " -- we overwrite the 'access_forward'-value with no; whatever it was...",
@ -162,7 +162,7 @@ namespace AspectedRouting.IO.itinero2
" end", " end",
" if(access_backward ~= nil and access_backward ~= \"no\" and access_backward ~= false) then", " if(access_backward ~= nil and access_backward ~= \"no\" and access_backward ~= false) then",
" tags.access = access_backward", " tags.access = access_backward",
" result.backward_speed = " + _skeleton.ToLua(_profile.Speed).Indent(), " result.backward_speed = " + _skeleton.ToLuaWithTags(_profile.Speed).Indent(),
" tags.speed = result.backward_speed", " tags.speed = result.backward_speed",
" local priority = calculate_priority(parameters, tags, result, access_backward, oneway, result.backward_speed)", " local priority = calculate_priority(parameters, tags, result, access_backward, oneway, result.backward_speed)",
" if (priority <= 0) then", " if (priority <= 0) then",

33
AspectedRouting/IO/jsonParser/JsonParser.ParseAspectProfile.cs
View file

@ -24,9 +24,12 @@ namespace AspectedRouting.IO.jsonParser
return null; return null;
} }
Console.WriteLine("Parsing " + fileName); Console.Write("Parsing " + fileName+"... ");
return doc.RootElement.ParseAspect(fileName, c); var aspect= doc.RootElement.ParseAspect(fileName, c);
Console.WriteLine($"\rAspect {aspect.Name} has type {string.Join(",", aspect.ExpressionImplementation.Types)}");
return aspect;
} }
catch (Exception e) catch (Exception e)
{ {
@ -90,15 +93,26 @@ namespace AspectedRouting.IO.jsonParser
filepath + " is not a valid profile; it does not contain the obligated parameter " + name); filepath + " is not a valid profile; it does not contain the obligated parameter " + name);
} }
var defaultParameters = e.GetProperty("defaults").ParseParameters();
var contextWithParameters = new Context(context);
foreach (var (paramName, paramExpression) in defaultParameters)
{
if (!context.Parameters.TryGetValue(paramName, out var previousParam))
{
contextWithParameters.AddParameter(paramName, paramExpression);
}
}
var vehicleTypes = GetTopProperty("vehicletypes").EnumerateArray().Select( var vehicleTypes = GetTopProperty("vehicletypes").EnumerateArray().Select(
el => el.GetString()).ToList(); el => el.GetString()).ToList();
var metadata = GetTopProperty("metadata").EnumerateArray().Select( var metadata = GetTopProperty("metadata").EnumerateArray().Select(
el => el.GetString()).ToList(); el => el.GetString()).ToList();
var access = ParseProfileProperty(e, context, "access").Finalize(); var access = ParseProfileProperty(e, contextWithParameters, "access").Finalize();
var oneway = ParseProfileProperty(e, context, "oneway").Finalize(); var oneway = ParseProfileProperty(e, contextWithParameters, "oneway").Finalize();
var speed = ParseProfileProperty(e, context, "speed").Finalize(); var speed = ParseProfileProperty(e, contextWithParameters, "speed").Finalize();
IExpression TagsApplied(IExpression x) IExpression TagsApplied(IExpression x)
@ -152,7 +166,7 @@ namespace AspectedRouting.IO.jsonParser
author, author,
filepath?.DirectoryName ?? "unknown", filepath?.DirectoryName ?? "unknown",
vehicleTypes, vehicleTypes,
e.GetProperty("defaults").ParseParameters(), defaultParameters,
profiles, profiles,
access, access,
oneway, oneway,
@ -293,6 +307,12 @@ namespace AspectedRouting.IO.jsonParser
if (s.StartsWith("#")) if (s.StartsWith("#"))
{ {
// This is a parameter, the type of it is free // This is a parameter, the type of it is free
if (context.Parameters.TryGetValue(s.Substring(1), out var param))
{
return new Parameter(s).Specialize(param.Types);
}
return new Parameter(s); return new Parameter(s);
} }
@ -511,7 +531,6 @@ namespace AspectedRouting.IO.jsonParser
} }
} }
Console.WriteLine($"Aspect {name} has type {string.Join(",", expr.Types)}");
return new AspectMetadata( return new AspectMetadata(
expr, expr,
name, name,

8
AspectedRouting/IO/jsonParser/JsonParser.cs
View file

@ -1,16 +1,18 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Runtime.CompilerServices;
using System.Text.Json; using System.Text.Json;
using AspectedRouting.Language; using AspectedRouting.Language;
using AspectedRouting.Language.Functions; using AspectedRouting.Language.Functions;
using AspectedRouting.Language.Typ; using AspectedRouting.Language.Typ;
[assembly: InternalsVisibleTo("AspectedRouting.Test")]
namespace AspectedRouting.IO.jsonParser namespace AspectedRouting.IO.jsonParser
{ {
public static partial class JsonParser public static partial class JsonParser
{ {
private static IExpression ParseProfileProperty(JsonElement e, Context c, string property) internal static IExpression ParseProfileProperty(JsonElement e, Context c, string property)
{ {
if (!e.TryGetProperty(property, out var prop)) { if (!e.TryGetProperty(property, out var prop)) {
throw new ArgumentException("Not a valid profile: the declaration expression for '" + property + throw new ArgumentException("Not a valid profile: the declaration expression for '" + property +
@ -23,7 +25,7 @@ namespace AspectedRouting.IO.jsonParser
throw new Exception($"Could not parse field {property}, no valid typing for expression found"); throw new Exception($"Could not parse field {property}, no valid typing for expression found");
} }
expr = expr.Optimize(); expr = expr.Optimize(out _);
expr = Funcs.Either(Funcs.Id, Funcs.Const, expr); expr = Funcs.Either(Funcs.Id, Funcs.Const, expr);
var specialized = expr.Specialize(new Curry(Typs.Tags, new Var("a"))); var specialized = expr.Specialize(new Curry(Typs.Tags, new Var("a")));
@ -52,7 +54,7 @@ namespace AspectedRouting.IO.jsonParser
string.Join(",", pruned.Types) + "\n" + pruned.TypeBreakdown()); string.Join(",", pruned.Types) + "\n" + pruned.TypeBreakdown());
} }
return pruned.Optimize(); return pruned.Optimize(out _);
} }
catch (Exception exc) { catch (Exception exc) {
throw new Exception("While parsing the property " + property, exc); throw new Exception("While parsing the property " + property, exc);

12
AspectedRouting/IO/lua/copy_tags.lua Normal file
View file

@ -0,0 +1,12 @@
--[[
copies all attributes from the source-table into the target-table,
but only if the key is listed in 'whitelist' (which is a set)
]]
function copy_tags(source, target, whitelist)
for k, v in pairs(source) do
if whitelist[k] then
target[k] = v
end
end
end

5
AspectedRouting/IO/lua/create_set.lua Normal file
View file

@ -0,0 +1,5 @@
function create_set(list)
local set = {}
for _, l in ipairs(list) do set[l] = true end
return set
end

3
AspectedRouting/IO/lua/is_null.lua Normal file
View file

@ -0,0 +1,3 @@
function is_null(a)
return a == nil;
end

2
AspectedRouting/IO/lua/must_match.lua
View file

@ -79,7 +79,7 @@ function must_match(needed_keys, table, tags, result)
-- Now that we know for sure that every key matches, we add them all to the 'attributes_to_keep' -- Now that we know for sure that every key matches, we add them all to the 'attributes_to_keep'
if (result == nil) then if (result == nil) then
-- euhm, well, seems like we don't are about the attributes_to_keep; early return! -- euhm, well, seems like we don't care about the attributes_to_keep; early return!
return true return true
end end
for _, key in ipairs(needed_keys) do for _, key in ipairs(needed_keys) do

3
AspectedRouting/IO/lua/unitTest.lua
View file

@ -5,8 +5,7 @@ function unit_test(f, fname, index, expected, parameters, tags)
failed_tests = true failed_tests = true
return return
end end
local result = {attributes_to_keep = {}} local actual = f(tags)
local actual = f(parameters, tags, result)
if(expected == "null" and actual == nil) then if(expected == "null" and actual == nil) then
-- OK! -- OK!
elseif(tonumber(actual) and tonumber(expected) and math.abs(tonumber(actual) - tonumber(expected)) < 0.1) then elseif(tonumber(actual) and tonumber(expected) and math.abs(tonumber(actual) - tonumber(expected)) < 0.1) then

3
AspectedRouting/Language/Analysis.cs
View file

@ -206,7 +206,7 @@ namespace AspectedRouting.Language
if (diff.Any()) { if (diff.Any()) {
throw new ArgumentException("No default value set for parameter: " + MetaList(diff)); throw new ArgumentException("No default value set for parameter: " + MetaList(diff));
} }
var unused = defaultParameters.Except(usedParameters); var unused = defaultParameters.Except(usedParameters);
if (unused.Any()) { if (unused.Any()) {
Console.WriteLine("[WARNING] A default value is set for parameter, but it is unused: " + Console.WriteLine("[WARNING] A default value is set for parameter, but it is unused: " +
@ -254,6 +254,7 @@ namespace AspectedRouting.Language
Console.WriteLine( Console.WriteLine(
$"[{pmd.Name}] WARNING: Some parameters only have a default value: {string.Join(", ", defaultOnly)}"); $"[{pmd.Name}] WARNING: Some parameters only have a default value: {string.Join(", ", defaultOnly)}");
} }
} }
public static void SanityCheck(this IExpression e) public static void SanityCheck(this IExpression e)

5
AspectedRouting/Language/Context.cs
View file

@ -33,6 +33,11 @@ namespace AspectedRouting.Language
{ {
Parameters.Add(name, new Constant(value)); Parameters.Add(name, new Constant(value));
} }
public void AddParameter(string name, IExpression value)
{
Parameters.Add(name, value);
}
public void AddFunction(string name, AspectMetadata function) public void AddFunction(string name, AspectMetadata function)
{ {

28
AspectedRouting/Language/Deconstruct.cs
View file

@ -47,6 +47,19 @@ namespace AspectedRouting.Language
}; };
} }
public static Func<IExpression, bool> IsConstant(List<Constant> collect)
{
return e =>
{
if (!(e is Constant c))
{
return false;
}
collect.Add(c);
return true;
};
}
public static Func<IExpression, bool> Assign(List<IExpression> collect) public static Func<IExpression, bool> Assign(List<IExpression> collect)
{ {
@ -66,6 +79,19 @@ namespace AspectedRouting.Language
return f.Name.Equals(fe.Name); return f.Name.Equals(fe.Name);
}; };
} }
public static Func<IExpression, bool> IsFunctionCall(List<string> names)
{
return e => {
if (!(e is FunctionCall fc)) {
return false;
}
names.Add(fc.CalledFunctionName);
return true;
};
}
public static Func<IExpression, bool> UnApplyAny( public static Func<IExpression, bool> UnApplyAny(
Func<IExpression, bool> matchFunc, Func<IExpression, bool> matchFunc,
@ -93,7 +119,7 @@ namespace AspectedRouting.Language
} }
else { else {
if (!doesMatch) { if (!doesMatch) {
// All must match - otherwise we might have registered a wrong collectiin // All must match - otherwise we might have registered a wrong collection
return false; return false;
} }
} }

336
AspectedRouting/Language/Expression/Apply.cs
View file

@ -19,6 +19,8 @@ namespace AspectedRouting.Language.Expression
/// </summary> /// </summary>
public readonly Dictionary<Type, (IExpression f, IExpression a)> FunctionApplications; public readonly Dictionary<Type, (IExpression f, IExpression a)> FunctionApplications;
private IExpression optimizedForm = null;
private Apply(string debugInfo, Dictionary<Type, (IExpression f, IExpression a)> argument) private Apply(string debugInfo, Dictionary<Type, (IExpression f, IExpression a)> argument)
{ {
_debugInfo = debugInfo; _debugInfo = debugInfo;
@ -27,15 +29,18 @@ namespace AspectedRouting.Language.Expression
public Apply(IExpression f, IExpression argument) public Apply(IExpression f, IExpression argument)
{ {
if (f == null || argument == null) { if (f == null || argument == null)
{
throw new NullReferenceException(); throw new NullReferenceException();
} }
FunctionApplications = new Dictionary<Type, (IExpression f, IExpression a)>(); FunctionApplications = new Dictionary<Type, (IExpression f, IExpression a)>();
var typesCleaned = argument.Types.RenameVars(f.Types).ToList(); var typesCleaned = argument.Types.RenameVars(f.Types).ToList();
foreach (var funcType in f.Types) { foreach (var funcType in f.Types)
if (!(funcType is Curry c)) { {
if (!(funcType is Curry c))
{
continue; continue;
} }
@ -43,10 +48,12 @@ namespace AspectedRouting.Language.Expression
var expectedResultType = c.ResultType; var expectedResultType = c.ResultType;
foreach (var argType in typesCleaned) { foreach (var argType in typesCleaned)
{
// we try to unify the argType with the expected type // we try to unify the argType with the expected type
var substitutions = expectedArgType.UnificationTable(argType); var substitutions = expectedArgType.UnificationTable(argType);
if (substitutions == null) { if (substitutions == null)
{
continue; continue;
} }
@ -56,25 +63,30 @@ namespace AspectedRouting.Language.Expression
var actualFunction = f.Specialize(new Curry(actualArgType, actualResultType)); var actualFunction = f.Specialize(new Curry(actualArgType, actualResultType));
var actualArgument = argument.Specialize(actualArgType); var actualArgument = argument.Specialize(actualArgType);
if (actualFunction == null || actualArgument == null) { if (actualFunction == null || actualArgument == null)
{
continue; continue;
} }
if (FunctionApplications.ContainsKey(actualResultType)) {
if (FunctionApplications.ContainsKey(actualResultType))
{
continue; continue;
} }
FunctionApplications.Add(actualResultType, (actualFunction, actualArgument)); FunctionApplications.Add(actualResultType, (actualFunction, actualArgument));
} }
} }
if (!FunctionApplications.Any()) { if (!FunctionApplications.Any())
try { {
_debugInfo = $"\n{f.Optimize().TypeBreakdown().Indent()}\n" + try
{
_debugInfo = $"\n{f.Optimize(out var _).TypeBreakdown().Indent()}\n" +
"is given the argument: " + "is given the argument: " +
"(" + argument.Optimize().TypeBreakdown() + ")"; "(" + argument.Optimize(out var _).TypeBreakdown() + ")";
} }
catch (Exception) { catch (Exception)
{
_debugInfo = $"\n (NO OPT) {f.TypeBreakdown().Indent()}\n" + _debugInfo = $"\n (NO OPT) {f.TypeBreakdown().Indent()}\n" +
"is given the argument: " + "is given the argument: " +
"(" + argument.TypeBreakdown() + ")"; "(" + argument.TypeBreakdown() + ")";
@ -90,7 +102,8 @@ namespace AspectedRouting.Language.Expression
public object Evaluate(Context c, params IExpression[] arguments) public object Evaluate(Context c, params IExpression[] arguments)
{ {
if (!Types.Any()) { if (!Types.Any())
{
throw new ArgumentException("Trying to invoke an invalid expression: " + this); throw new ArgumentException("Trying to invoke an invalid expression: " + this);
} }
@ -101,7 +114,8 @@ namespace AspectedRouting.Language.Expression
var arg = argExpr; var arg = argExpr;
var allArgs = new IExpression[arguments.Length + 1]; var allArgs = new IExpression[arguments.Length + 1];
allArgs[0] = arg; allArgs[0] = arg;
for (var i = 0; i < arguments.Length; i++) { for (var i = 0; i < arguments.Length; i++)
{
allArgs[i + 1] = arguments[i]; allArgs[i + 1] = arguments[i];
} }
@ -114,23 +128,42 @@ namespace AspectedRouting.Language.Expression
return Specialize(allowedTypes); return Specialize(allowedTypes);
} }
public IExpression PruneTypes(Func<Type, bool> allowedTypes) public IExpression PruneTypes(System.Func<Type, bool> allowedTypes)
{ {
var passed = this.FunctionApplications.Where(kv => allowedTypes.Invoke(kv.Key)); var passed = FunctionApplications.Where(kv => allowedTypes.Invoke(kv.Key));
if (!passed.Any()) { if (!passed.Any())
{
return null; return null;
} }
return new Apply("pruned", new Dictionary<Type, (IExpression A, IExpression F)>(passed)); return new Apply("pruned", new Dictionary<Type, (IExpression A, IExpression F)>(passed));
} }
public IExpression Optimize() public IExpression Optimize(out bool somethingChanged)
{ {
if (Types.Count() == 0) { if (this.optimizedForm != null)
{
somethingChanged = this.optimizedForm != this;
return this.optimizedForm;
}
this.optimizedForm = this.OptimizeInternal(out somethingChanged);
if (!optimizedForm.Types.Any())
{
throw new Exception("Optimizing " + this.ToString() + " failed: cannot be typechecked anymore");
}
return this.optimizedForm;
}
internal IExpression OptimizeInternal(out bool somethingChanged)
{
if (Types.Count() == 0)
{
throw new ArgumentException("This application contain no valid types, so cannot be optimized" + this); throw new ArgumentException("This application contain no valid types, so cannot be optimized" + this);
} }
somethingChanged = false;
// (eitherfunc dot id) id // (eitherfunc dot id) id
// => (const dot _) id => dot id => id // => (const dot _) id => dot id => id
// or => (constRight _ id) id => id id => id // or => (constRight _ id) id => id id => id
if ( if (
UnApplyAny( UnApplyAny(
@ -147,23 +180,37 @@ namespace AspectedRouting.Language.Expression
Any), Any),
IsFunc(Funcs.Id)), IsFunc(Funcs.Id)),
IsFunc(Funcs.Id) IsFunc(Funcs.Id)
).Invoke(this)) { ).Invoke(this))
{
somethingChanged = true;
return Funcs.Id; return Funcs.Id;
} }
if (Types.Count() > 1) { if (Types.Count() > 1)
// Too much types to optimize {
// Too much types to optimize: we optimize the subparts instead
var optimized = new Dictionary<Type, (IExpression f, IExpression a)>(); var optimized = new Dictionary<Type, (IExpression f, IExpression a)>();
foreach (var (resultType, (f, a)) in FunctionApplications) { foreach (var (resultType, (f, a)) in FunctionApplications)
var fOpt = f.Optimize(); {
var aOpt = a.Optimize(); var fOpt = f.Optimize(out var scf);
var aOpt = a.Optimize(out var sca);
somethingChanged |= scf || sca;
optimized.Add(resultType, (fOpt, aOpt)); optimized.Add(resultType, (fOpt, aOpt));
} }
return new Apply(_debugInfo, optimized); if (somethingChanged)
{
return new Apply(_debugInfo, optimized);
}
return this;
} }
// At this point, we know there only is a single type;
// We can safely assume all the 'assign' will only match a single entry
{ {
// id a => a // id a => a
var arg = new List<IExpression>(); var arg = new List<IExpression>();
@ -171,11 +218,40 @@ namespace AspectedRouting.Language.Expression
UnApplyAny( UnApplyAny(
IsFunc(Funcs.Id), IsFunc(Funcs.Id),
Assign(arg) Assign(arg)
).Invoke(this)) { ).Invoke(this))
return arg.First(); {
var argOpt = arg.First().Optimize(out _);
somethingChanged = true;
return argOpt;
} }
} }
{
var exprs = new List<Constant>();
var arg = new List<IExpression>();
// listDot ([f0, f1, f2, ...]) arg ---> [f0 arg, f1 arg, f2 arg, ...]
if (UnApply(
UnApply(
IsFunc(Funcs.ListDot),
IsConstant(exprs)
),
Assign(arg)
).Invoke(this))
{
var a = arg.First();
var c = exprs.First();
if (c.Types.All(t => t is ListType))
{
// The constant is a list
var o = (List<IExpression>)c.Get();
somethingChanged = true;
return new Constant(
o.Select(e => e.Apply(a).Optimize(out var _)).ToList()
);
}
// fallthrough!
}
}
{ {
// ifdotted fcondition fthen felse arg => if (fcondition arg) (fthen arg) (felse arg) // ifdotted fcondition fthen felse arg => if (fcondition arg) (fthen arg) (felse arg)
@ -194,38 +270,104 @@ namespace AspectedRouting.Language.Expression
Assign(fthen)), Assign(fthen)),
Assign(felse)), Assign(felse)),
Assign(arg) Assign(arg)
).Invoke(this)) { ).Invoke(this))
{
var a = arg.First(); var a = arg.First();
somethingChanged = true;
return return
Funcs.If.Apply( Funcs.If.Apply(
fcondition.First().Apply(a), fcondition.First().Apply(a).Optimize(out var _),
fthen.First().Apply(a), fthen.First().Apply(a).Optimize(out var _),
felse.First().Apply(a) felse.First().Apply(a).Optimize(out var _)
); );
} }
} }
{
// ifdotted fcondition fthen <null> arg => if (fcondition arg) (fthen arg) (felse arg)
var fcondition = new List<IExpression>();
var fthen = new List<IExpression>();
var arg = new List<IExpression>();
if (
this.Types.Any(t => !(t is Curry)) &&
UnApply(
UnApply(
UnApply(
IsFunc(Funcs.IfDotted),
Assign(fcondition)),
Assign(fthen)),
Assign(arg)
).Invoke(this))
{
var a = arg.First();
somethingChanged = true;
return
Funcs.If.Apply(
fcondition.First().Apply(a).Optimize(out var _),
fthen.First().Apply(a).Optimize(out var _)
).Specialize(this.Types).PruneTypes(t => !(t is Curry)).Optimize(out _);
}
}
{ {
// (default x f) a --> if (isNull (f a)) x (f a)
var defaultArg = new List<IExpression>();
var f = new List<IExpression>();
var a = new List<IExpression>();
if (
UnApply(
UnApply(
UnApply(
IsFunc(Funcs.Default),
Assign(defaultArg)
),
Assign(f)
), Assign(a)
).Invoke(this))
{
somethingChanged = true;
var fa = f.First().Apply(a.First()).Optimize(out var _);
return Funcs.If.Apply(
Funcs.IsNull.Apply(fa)
).Apply(defaultArg).Apply(fa);
}
}
{
// The fallback case
// We couldn't optimize with a pattern, but the subparts might be optimizable
var (f, a) = FunctionApplications.Values.First(); var (f, a) = FunctionApplications.Values.First();
var (newFa, expr) = OptimizeApplicationPair(f, a); var (newFa, expr) = OptimizeApplicationPair(f, a, out var changed);
if (expr != null) { if (expr != null)
{
somethingChanged = true;
return expr; return expr;
} }
(f, a) = newFa.Value; if (changed)
return new Apply(f, a); {
somethingChanged = true;
(f, a) = newFa.Value;
return new Apply(f, a).Optimize(out _);
}
} }
return this;
} }
public void Visit(Func<IExpression, bool> visitor) public void Visit(Func<IExpression, bool> visitor)
{ {
var continueVisit = visitor(this); var continueVisit = visitor(this);
if (!continueVisit) { if (!continueVisit)
{
return; return;
} }
foreach (var (_, (f, a)) in FunctionApplications) { foreach (var (_, (f, a)) in FunctionApplications)
{
f.Visit(visitor); f.Visit(visitor);
a.Visit(visitor); a.Visit(visitor);
} }
@ -235,10 +377,13 @@ namespace AspectedRouting.Language.Expression
{ {
var newArgs = new Dictionary<Type, (IExpression f, IExpression a)>(); var newArgs = new Dictionary<Type, (IExpression f, IExpression a)>();
foreach (var allowedType in allowedTypes) { foreach (var allowedType in allowedTypes)
foreach (var (resultType, (funExpr, argExpr)) in FunctionApplications) { {
foreach (var (resultType, (funExpr, argExpr)) in FunctionApplications)
{
var substitutions = resultType.UnificationTable(allowedType, true); var substitutions = resultType.UnificationTable(allowedType, true);
if (substitutions == null) { if (substitutions == null)
{
continue; continue;
} }
@ -250,7 +395,8 @@ namespace AspectedRouting.Language.Expression
var actualFunction = funExpr.Specialize(substitutions); var actualFunction = funExpr.Specialize(substitutions);
var actualArgument = argExpr.Specialize(substitutions); var actualArgument = argExpr.Specialize(substitutions);
if (actualFunction == null || actualArgument == null) { if (actualFunction == null || actualArgument == null)
{
// One of the subexpressions can't be optimized // One of the subexpressions can't be optimized
return null; return null;
} }
@ -259,34 +405,47 @@ namespace AspectedRouting.Language.Expression
} }
} }
if (!newArgs.Any()) { if (!newArgs.Any())
{
return null; return null;
} }
return new Apply(_debugInfo, newArgs); return new Apply(_debugInfo, newArgs);
} }
private ((IExpression fOpt, IExpression fArg)?, IExpression result) OptimizeApplicationPair(IExpression f, private ((IExpression fOpt, IExpression fArg)?, IExpression result) OptimizeApplicationPair(
IExpression a) IExpression fRaw,
IExpression a,
out bool somethingChanged)
{ {
f = f.Optimize(); somethingChanged = false;
var f = fRaw.Optimize(out var scf);
somethingChanged |= scf;
if (f.Types.Count() == 0)
{
throw new ArgumentException("Optimizing " + f + " failed, no types returned. The original expression\n "+fRaw.ToString()+"has types"+string.Join("\n ", fRaw.Types));
}
a = a.Optimize(); a = a.Optimize(out var sca);
somethingChanged |= sca;
switch (f) { switch (f)
{
case Id _: case Id _:
return (null, a); return (null, a);
case Apply apply: case Apply apply:
if (apply.F is Const _) { if (apply.F is Const _)
{
// (const x) y -> y // (const x) y -> y
// apply == (const x) thus we return 'x' and ignore 'a' // apply == (const x) thus we return 'x' and ignore 'a'
return (null, apply.A); return (null, apply.A);
} }
if (apply.F is ConstRight _) { if (apply.F is ConstRight _)
{
// constRight x y -> y // constRight x y -> y
// apply == (constRight x) so we return a // apply == (constRight x) so we return a
return (null, a); return (null, a);
@ -300,12 +459,14 @@ namespace AspectedRouting.Language.Expression
Assign(f0) Assign(f0)
), ),
Assign(f1)).Invoke(apply) Assign(f1)).Invoke(apply)
) { )
{
// apply == ((dot f0) f1) // apply == ((dot f0) f1)
// ((dot f0) f1) a is the actual expression, but arg is already split of // ((dot f0) f1) a is the actual expression, but arg is already split of
// f0 (f1 arg) // f0 (f1 arg)
// which used to be (f0 . f1) arg // which used to be (f0 . f1) arg
somethingChanged = true;
return ((f0.First(), new Apply(f1.First(), a)), null); return ((f0.First(), new Apply(f1.First(), a)), null);
} }
@ -318,21 +479,82 @@ namespace AspectedRouting.Language.Expression
public override string ToString() public override string ToString()
{ {
if (!FunctionApplications.Any()) { if (!FunctionApplications.Any())
{
return "NOT-TYPECHECKABLE APPLICATION: " + _debugInfo; return "NOT-TYPECHECKABLE APPLICATION: " + _debugInfo;
} }
var (f, arg) = FunctionApplications.Values.First(); var (f, arg) = FunctionApplications.Values.First();
if (f is Id _) { if (f is Id _)
{
return arg.ToString(); return arg.ToString();
} }
var extra = ""; var extra = "";
if (FunctionApplications.Count() > 1) { if (FunctionApplications.Count() > 1)
{
extra = " [" + FunctionApplications.Count + " IMPLEMENTATIONS]"; extra = " [" + FunctionApplications.Count + " IMPLEMENTATIONS]";
} }
return $"({f} {arg.ToString().Indent()})" + extra; return $"({f} {arg.ToString().Indent()})" + extra;
} }
public bool Equals(IExpression other)
{
if (!(other is Apply apply))
{
return false;
}
var otherOptions = apply.FunctionApplications;
if (otherOptions.Count != FunctionApplications.Count)
{
return false;
}
foreach (var (type, (otherF, otherA)) in otherOptions)
{
if (!FunctionApplications.TryGetValue(type, out var tuple))
{
return false;
}
if (!otherF.Equals(tuple.f))
{
return false;
}
if (!otherA.Equals(tuple.a))
{
return false;
}
}
return true;
}
public string Repr()
{
if (this.Types.Count() == 1)
{
var f = this.F.Repr().Replace("\n", "\n ");
var a = this.A.Repr().Replace("\n", "\n ");
return $"new Apply( // {string.Join(" ; ", this.Types)}\n {f},\n {a})";
}
var r = "new Apply(";
foreach (var (type, (f, a)) in this.FunctionApplications)
{
r += "\n // " + type+"\n";
r += " | " + f.Repr().Replace("\n", "\n | ")+",\n";
r += " | " + a.Repr().Replace("\n", "\n | ")+"\n";
}
return r;
}
} }
} }

35
AspectedRouting/Language/Expression/AspectMetadata.cs
View file

@ -32,7 +32,6 @@ namespace AspectedRouting.Language.Expression
public object Evaluate(Context c, params IExpression[] arguments) public object Evaluate(Context c, params IExpression[] arguments)
{ {
return ExpressionImplementation.Evaluate(c, arguments); return ExpressionImplementation.Evaluate(c, arguments);
} }
@ -43,20 +42,29 @@ namespace AspectedRouting.Language.Expression
Name, Description, Author, Unit, Filepath); Name, Description, Author, Unit, Filepath);
} }
public IExpression PruneTypes(System.Func<Type, bool> allowedTypes) public IExpression PruneTypes(Func<Type, bool> allowedTypes)
{ {
var e = ExpressionImplementation.PruneTypes(allowedTypes); var e = ExpressionImplementation.PruneTypes(allowedTypes);
if (e == null) { if (e == null)
{
return null; return null;
} }
return new AspectMetadata(e, Name, Description, Author, Unit, return new AspectMetadata(e, Name, Description, Author, Unit,
Filepath, ProfileInternal); Filepath, ProfileInternal);
} }
public IExpression Optimize() public IExpression Optimize(out bool somethingChanged)
{ {
return new AspectMetadata(ExpressionImplementation.Optimize(), var optE = ExpressionImplementation.Optimize(out var sc);
Name, Description, Author, Unit, Filepath); somethingChanged = sc;
if (sc)
{
return new AspectMetadata(optE,
Name, Description, Author, Unit, Filepath);
}
return this;
} }
public void Visit(Func<IExpression, bool> f) public void Visit(Func<IExpression, bool> f)
@ -74,5 +82,20 @@ namespace AspectedRouting.Language.Expression
{ {
return $"# {Name}; {Unit} by {Author}\n\n# by {Author}\n# {Description}\n{ExpressionImplementation}"; return $"# {Name}; {Unit} by {Author}\n\n# by {Author}\n# {Description}\n{ExpressionImplementation}";
} }
public bool Equals(IExpression other)
{
if (other is AspectMetadata amd)
{
return amd.ExpressionImplementation.Equals(ExpressionImplementation);
}
return false;
}
public string Repr()
{
return "Aspect_" + Name;
}
} }
} }

18
AspectedRouting/Language/Expression/Function.cs
View file

@ -44,8 +44,9 @@ namespace AspectedRouting.Language.Expression
return new FunctionCall(this.Name, passedTypes); return new FunctionCall(this.Name, passedTypes);
} }
public virtual IExpression Optimize() public virtual IExpression Optimize(out bool somethingChanged)
{ {
somethingChanged = false;
return this; return this;
} }
@ -100,5 +101,20 @@ namespace AspectedRouting.Language.Expression
return dict; return dict;
} }
public bool Equals(IExpression other)
{
if (other is Function f)
{
return f.Name.Equals(this.Name);
}
return false;
}
public string Repr()
{
return "Funcs."+this.Name;
}
} }
} }

24
AspectedRouting/Language/Expression/FunctionCall.cs
View file

@ -33,7 +33,11 @@ namespace AspectedRouting.Language.Expression
Types = types; Types = types;
} }
public object Evaluate(Context c, params IExpression[] arguments) public FunctionCall(string name, Type type): this(name, new []{type}){
}
public object Evaluate(Context c, params IExpression[] arguments)
{ {
var func = c.GetFunction(_name); var func = c.GetFunction(_name);
@ -62,8 +66,9 @@ namespace AspectedRouting.Language.Expression
return new FunctionCall(this._name, passedTypes); return new FunctionCall(this._name, passedTypes);
} }
public IExpression Optimize() public IExpression Optimize(out bool somethingChanged)
{ {
somethingChanged = false;
return this; return this;
} }
@ -87,6 +92,21 @@ namespace AspectedRouting.Language.Expression
f(this); f(this);
} }
public bool Equals(IExpression other)
{
if (other is FunctionCall fc)
{
return fc._name.Equals(this._name);
}
return false;
}
public string Repr()
{
return "new FunctionCall(\"" + this._name + "\")";
}
public override string ToString() public override string ToString()
{ {
return $"${_name}"; return $"${_name}";

72
AspectedRouting/Language/Expression/ProfileMetaData.cs
View file

@ -14,7 +14,7 @@ namespace AspectedRouting.Language.Expression
public string Author { get; } public string Author { get; }
public string Filename { get; } public string Filename { get; }
public List<string> VehicleTyps { get; } public List<string> VehicleTyps { get; }
/* /*
* Which tags are included in the routerdb but are _not_ used for routeplanning? * Which tags are included in the routerdb but are _not_ used for routeplanning?
* Typically these are tags that are useful for navigation (name of the road, is this a tunnel, ...) * Typically these are tags that are useful for navigation (name of the road, is this a tunnel, ...)
@ -29,6 +29,7 @@ namespace AspectedRouting.Language.Expression
public IExpression Oneway { get; } public IExpression Oneway { get; }
public IExpression Speed { get; } public IExpression Speed { get; }
public Dictionary<string, IExpression> Priority { get; } public Dictionary<string, IExpression> Priority { get; }
/** /**
* Moment of last change of any upstream file * Moment of last change of any upstream file
*/ */
@ -45,9 +46,9 @@ namespace AspectedRouting.Language.Expression
Author = author; Author = author;
Filename = filename; Filename = filename;
VehicleTyps = vehicleTyps; VehicleTyps = vehicleTyps;
Access = access.Optimize(); Access = access.Optimize(out var _);
Oneway = oneway.Optimize(); Oneway = oneway.Optimize(out var _);
Speed = speed.Optimize(); Speed = speed.Optimize(out var _);
Priority = priority; Priority = priority;
Metadata = metadata; Metadata = metadata;
LastChange = lastChange; LastChange = lastChange;
@ -57,21 +58,22 @@ namespace AspectedRouting.Language.Expression
CheckTypes(Access, "access"); CheckTypes(Access, "access");
CheckTypes(Oneway, "oneway"); CheckTypes(Oneway, "oneway");
CheckTypes(Speed, "speed"); CheckTypes(Speed, "speed");
} }
private static void CheckTypes(IExpression e, string name) private static void CheckTypes(IExpression e, string name)
{ {
if (e.Types.Count() == 1) { if (e.Types.Count() == 1)
{
return; return;
} }
throw new Exception("Insufficient specialization: " + name + " has multiple types left, namely " + e.Types.Pretty()); throw new Exception("Insufficient specialization: " + name + " has multiple types left, namely " +
e.Types.Pretty());
} }
public List<IExpression> AllExpressions(Context ctx) public List<IExpression> AllExpressions(Context ctx)
{ {
var l = new List<IExpression> {Access, Oneway, Speed}; var l = new List<IExpression> { Access, Oneway, Speed };
l.AddRange(DefaultParameters.Values); l.AddRange(DefaultParameters.Values);
l.AddRange(Behaviours.Values.SelectMany(b => b.Values)); l.AddRange(Behaviours.Values.SelectMany(b => b.Values));
l.AddRange(Priority.Values); l.AddRange(Priority.Values);
@ -88,6 +90,7 @@ namespace AspectedRouting.Language.Expression
var called = ctx.GetFunction(fc.CalledFunctionName); var called = ctx.GetFunction(fc.CalledFunctionName);
allExpr.Add(called); allExpr.Add(called);
} }
return true; return true;
}); });
} }
@ -95,6 +98,41 @@ namespace AspectedRouting.Language.Expression
return allExpr; return allExpr;
} }
public List<IExpression> AllExpressionsFor(string behaviourName, Context context)
{
var allExpressions = new List<IExpression>();
allExpressions.Add(Access);
allExpressions.Add(Oneway);
allExpressions.Add(Speed);
var behaviourContext = new Context(context);
var behaviourParameters = ParametersFor(behaviourName);
foreach (var (paramName, valueexpression) in Priority)
{
var weightingFactor = behaviourParameters[paramName].Evaluate(behaviourContext);
if (weightingFactor is double d)
{
if (d == 0.0)
{
continue;
}
}
if (weightingFactor is int i)
{
if (i == 0)
{
continue;
}
}
allExpressions.Add(valueexpression);
}
return allExpressions;
}
public Dictionary<string, IExpression> ParametersFor(string behaviour) public Dictionary<string, IExpression> ParametersFor(string behaviour)
{ {
@ -122,11 +160,11 @@ namespace AspectedRouting.Language.Expression
} }
c = c.WithParameters(ParametersFor(behaviour)) c = c.WithParameters(ParametersFor(behaviour))
.WithAspectName(this.Name); .WithAspectName(Name);
tags = new Dictionary<string, string>(tags); tags = new Dictionary<string, string>(tags);
var canAccess = Access.Run(c, tags); var canAccess = Access.Run(c, tags);
tags["access"] = "" + canAccess; tags["access"] = "" + canAccess;
var speed = (double) Speed.Run(c, tags); var speed = (double)Speed.Run(c, tags);
tags["speed"] = "" + speed; tags["speed"] = "" + speed;
var oneway = Oneway.Run(c, tags); var oneway = Oneway.Run(c, tags);
tags["oneway"] = "" + oneway; tags["oneway"] = "" + oneway;
@ -143,7 +181,7 @@ namespace AspectedRouting.Language.Expression
var weightExplanation = new List<string>(); var weightExplanation = new List<string>();
foreach (var (paramName, expression) in Priority) foreach (var (paramName, expression) in Priority)
{ {
var aspectInfluence = (double) c.Parameters[paramName].Evaluate(c); var aspectInfluence = (double)c.Parameters[paramName].Evaluate(c);
// ReSharper disable once CompareOfFloatsByEqualityOperator // ReSharper disable once CompareOfFloatsByEqualityOperator
if (aspectInfluence == 0) if (aspectInfluence == 0)
{ {
@ -193,8 +231,16 @@ namespace AspectedRouting.Language.Expression
canAccess = "no"; canAccess = "no";
} }
return new ProfileResult((string) canAccess, (string) oneway, speed, priority, if (canAccess is string canAccessString && oneway is string onewayString)
string.Join("\n ", weightExplanation)); {
return new ProfileResult(canAccessString, onewayString, speed, priority,
string.Join("\n ", weightExplanation));
}
else
{
throw new Exception("CanAccess or oneway are not strings but " + canAccess.GetType().ToString() +
" and " + (oneway?.GetType()?.ToString() ?? "<null>"));
}
} }

10
AspectedRouting/Language/Funcs.cs
View file

@ -19,6 +19,7 @@ namespace AspectedRouting.Language
public static readonly Function Eq = new Eq(); public static readonly Function Eq = new Eq();
public static readonly Function NotEq = new NotEq(); public static readonly Function NotEq = new NotEq();
public static readonly Function Inv = new Inv(); public static readonly Function Inv = new Inv();
public static readonly Function IsNull = new IsNull();
public static readonly Function Default = new Default(); public static readonly Function Default = new Default();
@ -94,7 +95,7 @@ namespace AspectedRouting.Language
// TODO FIX THIS so that it works // TODO FIX THIS so that it works
// An argument 'optimizes' it's types from 'string -> bool' to 'string -> string' // An argument 'optimizes' it's types from 'string -> bool' to 'string -> string'
var eOpt = eSmallest.Optimize(); var eOpt = eSmallest.Optimize(out _);
if (eOpt == null || eOpt.Types.Count() == 0) if (eOpt == null || eOpt.Types.Count() == 0)
{ {
throw new Exception("Could not optimize " + eSmallest); throw new Exception("Could not optimize " + eSmallest);
@ -106,6 +107,10 @@ namespace AspectedRouting.Language
public static IExpression SpecializeToSmallestType(this IExpression e) public static IExpression SpecializeToSmallestType(this IExpression e)
{ {
if (e == null)
{
throw new Exception("Cannot specialize null to a smallest type");
}
if (e.Types.Count() == 1) if (e.Types.Count() == 1)
{ {
return e; return e;
@ -160,7 +165,8 @@ namespace AspectedRouting.Language
var lastArg = args[args.Count - 1]; var lastArg = args[args.Count - 1];
var firstArgs = args.GetRange(0, args.Count - 1); var firstArgs = args.GetRange(0, args.Count - 1);
return new Apply(Apply(function, firstArgs), lastArg); var applied = Apply(function, firstArgs);
return new Apply(applied, lastArg);
} }
} }
} }

192
AspectedRouting/Language/Functions/Constant.cs
View file

@ -14,9 +14,11 @@ namespace AspectedRouting.Language.Functions
public Constant(IEnumerable<Type> types, object o) public Constant(IEnumerable<Type> types, object o)
{ {
Types = types.ToList(); Types = types.ToList();
if (o is IEnumerable<IExpression> enumerable) { if (o is IEnumerable<IExpression> enumerable)
{
o = enumerable.ToList(); o = enumerable.ToList();
if (enumerable.Any(x => x == null)) { if (enumerable.Any(x => x == null))
{
throw new NullReferenceException("Some subexpression is null"); throw new NullReferenceException("Some subexpression is null");
} }
} }
@ -26,10 +28,12 @@ namespace AspectedRouting.Language.Functions
public Constant(Type t, object o) public Constant(Type t, object o)
{ {
Types = new List<Type> {t}; Types = new List<Type> { t };
if (o is IEnumerable<IExpression> enumerable) { if (o is IEnumerable<IExpression> enumerable)
{
o = enumerable.ToList(); o = enumerable.ToList();
if (enumerable.Any(x => x == null)) { if (enumerable.Any(x => x == null))
{
throw new NullReferenceException("Some subexpression is null"); throw new NullReferenceException("Some subexpression is null");
} }
} }
@ -42,7 +46,8 @@ namespace AspectedRouting.Language.Functions
var tps = exprs var tps = exprs
.SpecializeToCommonTypes(out var specializedVersions) .SpecializeToCommonTypes(out var specializedVersions)
.Select(t => new ListType(t)); .Select(t => new ListType(t));
if (specializedVersions.Any(x => x == null)) { if (specializedVersions.Any(x => x == null))
{
throw new Exception("Specializing to common types failed for " + throw new Exception("Specializing to common types failed for " +
string.Join(",", exprs.Select(e => e.ToString()))); string.Join(",", exprs.Select(e => e.ToString())));
} }
@ -53,40 +58,50 @@ namespace AspectedRouting.Language.Functions
public Constant(IReadOnlyCollection<IExpression> exprs) public Constant(IReadOnlyCollection<IExpression> exprs)
{ {
try { try
{
Types = exprs Types = exprs
.SpecializeToCommonTypes(out var specializedVersions) .SpecializeToCommonTypes(out var specializedVersions)
.Select(t => new ListType(t)) .Select(t => new ListType(t))
.ToList(); .ToList();
if (specializedVersions.Any(x => x == null)) { specializedVersions = specializedVersions.ToList();
throw new NullReferenceException("Some subexpression is null"); if (specializedVersions.Any(x => x == null))
{
Console.Error.WriteLine(">> Some subexpressions of the list are null:");
foreach (var expr in exprs)
{
Console.Error.WriteLine(expr.Repr());
Console.Error.WriteLine("\n-------------------------\n");
}
throw new NullReferenceException("Some subexpression of specialized versions are null");
} }
_o = specializedVersions.ToList(); _o = specializedVersions.ToList();
} }
catch (Exception e) { catch (Exception e)
{
throw new Exception("While creating a list with members " + throw new Exception("While creating a list with members " +
string.Join(", ", exprs.Select(x => x.Optimize())) + string.Join(", ", exprs.Select(x => x.Optimize(out var _))) +
$" {e.Message}", e); $" {e.Message}", e);
} }
} }
public Constant(string s) public Constant(string s)
{ {
Types = new List<Type> {Typs.String}; Types = new List<Type> { Typs.String };
_o = s; _o = s;
} }
public Constant(double d) public Constant(double d)
{ {
if (d >= 0) { if (d >= 0)
Types = new[] {Typs.Double, Typs.PDouble}; {
Types = new[] { Typs.Double, Typs.PDouble };
} }
else { else
Types = new[] {Typs.Double}; {
Types = new[] { Typs.Double };
} }
_o = d; _o = d;
@ -94,11 +109,13 @@ namespace AspectedRouting.Language.Functions
public Constant(int i) public Constant(int i)
{ {
if (i >= 0) { if (i >= 0)
Types = new[] {Typs.Double, Typs.Nat, Typs.Nat, Typs.PDouble}; {
Types = new[] { Typs.Double, Typs.Nat, Typs.Nat, Typs.PDouble };
} }
else { else
Types = new[] {Typs.Double, Typs.Int}; {
Types = new[] { Typs.Double, Typs.Int };
} }
_o = i; _o = i;
@ -106,16 +123,17 @@ namespace AspectedRouting.Language.Functions
public Constant(Dictionary<string, string> tags) public Constant(Dictionary<string, string> tags)
{ {
Types = new[] {Typs.Tags}; Types = new[] { Typs.Tags };
_o = tags; _o = tags;
} }
public IEnumerable<Type> Types { get; } public IEnumerable<Type> Types { get; }
public IExpression PruneTypes(System.Func<Type, bool> allowedTypes) public IExpression PruneTypes(Func<Type, bool> allowedTypes)
{ {
var passedTypes = Types.Where(allowedTypes); var passedTypes = Types.Where(allowedTypes);
if (!passedTypes.Any()) { if (!passedTypes.Any())
{
return null; return null;
} }
@ -124,28 +142,32 @@ namespace AspectedRouting.Language.Functions
public object Evaluate(Context c, params IExpression[] args) public object Evaluate(Context c, params IExpression[] args)
{ {
if (_o is IExpression e) { if (_o is IExpression e)
{
return e.Evaluate(c).Pretty(); return e.Evaluate(c).Pretty();
} }
if (Types.Count() > 1) { if (Types.Count() > 1)
{
return _o; return _o;
} }
var t = Types.First(); var t = Types.First();
switch (t) { switch (t)
{
case DoubleType _: case DoubleType _:
case PDoubleType _: case PDoubleType _:
if (_o is int i) { if (_o is int i)
{
return return
(double) i; // I know, it seems absurd having to write this as it is nearly the same as the return beneath, but it _is_ needed (double)i; // I know, it seems absurd having to write this as it is nearly the same as the return beneath, but it _is_ needed
} }
return (double) _o; return (double)_o;
case IntType _: case IntType _:
case NatType _: case NatType _:
return (int) _o; return (int)_o;
} }
return _o; return _o;
@ -155,31 +177,39 @@ namespace AspectedRouting.Language.Functions
{ {
var allowedTypes = allowedTypesEnumerable.ToList(); var allowedTypes = allowedTypesEnumerable.ToList();
var unified = Types.SpecializeTo(allowedTypes); var unified = Types.SpecializeTo(allowedTypes);
if (unified == null) { if (unified == null)
{
return null; return null;
} }
var newO = _o; var newO = _o;
if (_o is IExpression e) { if (_o is IExpression e)
{
newO = e.Specialize(allowedTypes); newO = e.Specialize(allowedTypes);
} }
if (_o is IEnumerable<IExpression> es) { if (_o is IEnumerable<IExpression> es)
{
var innerTypes = new List<Type>(); var innerTypes = new List<Type>();
foreach (var allowedType in allowedTypes) { foreach (var allowedType in allowedTypes)
if (allowedType is ListType listType) { {
if (allowedType is ListType listType)
{
innerTypes.Add(listType.InnerType); innerTypes.Add(listType.InnerType);
} }
} }
var specializedExpressions = new List<IExpression>(); var specializedExpressions = new List<IExpression>();
foreach (var expr in es) { foreach (var expr in es)
if (expr == null) { {
if (expr == null)
{
throw new NullReferenceException("Subexpression is null"); throw new NullReferenceException("Subexpression is null");
} }
var specialized = expr.Specialize(innerTypes); var specialized = expr.Specialize(innerTypes);
if (specialized == null) { if (specialized == null)
{
// If a subexpression can not be specialized, this list cannot be specialized // If a subexpression can not be specialized, this list cannot be specialized
return null; return null;
} }
@ -193,26 +223,38 @@ namespace AspectedRouting.Language.Functions
return new Constant(unified, newO); return new Constant(unified, newO);
} }
public IExpression Optimize() public IExpression Optimize(out bool somethingChanged)
{ {
if (_o is IEnumerable<IExpression> exprs) { somethingChanged = false;
if (_o is IEnumerable<IExpression> exprs)
{
// This is a list // This is a list
var optExprs = new List<IExpression>(); var optExprs = new List<IExpression>();
foreach (var expression in exprs) { foreach (var expression in exprs)
var exprOpt = expression.Optimize(); {
if (exprOpt == null || exprOpt.Types.Count() == 0) { var exprOpt = expression.Optimize(out var sc);
somethingChanged |= sc;
if (exprOpt == null || exprOpt.Types.Count() == 0)
{
throw new ArgumentException("Non-optimizable expression:" + expression); throw new ArgumentException("Non-optimizable expression:" + expression);
} }
optExprs.Add(exprOpt); optExprs.Add(exprOpt);
} }
return new Constant(optExprs); if (somethingChanged)
{
return new Constant(optExprs);
}
return this;
} }
if (_o is IExpression expr) { if (_o is IExpression expr)
// This is a list {
return new Constant(expr.Types, expr.Optimize()); // This is a subexpression
somethingChanged = true;
return expr.Optimize(out var _);
} }
return this; return this;
@ -220,12 +262,15 @@ namespace AspectedRouting.Language.Functions
public void Visit(Func<IExpression, bool> f) public void Visit(Func<IExpression, bool> f)
{ {
if (_o is IExpression e) { if (_o is IExpression e)
{
e.Visit(f); e.Visit(f);
} }
if (_o is IEnumerable<IExpression> es) { if (_o is IEnumerable<IExpression> es)
foreach (var x in es) { {
foreach (var x in es)
{
x.Visit(f); x.Visit(f);
} }
} }
@ -233,6 +278,28 @@ namespace AspectedRouting.Language.Functions
f(this); f(this);
} }
public bool Equals(IExpression other)
{
if (other is Constant c)
{
return c._o.Equals(_o);
}
return false;
}
public string Repr()
{
if (_o is IEnumerable<IExpression> exprs)
{
return "new Constant(new []{" +
string.Join(",\n ", exprs.Select(e => e.Repr().Replace("\n","\n ")))
+ "})";
}
return "new Constant(" + (_o?.ToString() ?? null)+ ")";
}
public void EvaluateAll(Context c, HashSet<IExpression> addTo) public void EvaluateAll(Context c, HashSet<IExpression> addTo)
{ {
addTo.Add(this); addTo.Add(this);
@ -247,26 +314,35 @@ namespace AspectedRouting.Language.Functions
{ {
return ObjectExtensions.Pretty(_o); return ObjectExtensions.Pretty(_o);
} }
public object Get()
{
return _o;
}
} }
public static class ObjectExtensions public static class ObjectExtensions
{ {
public static string Pretty(this object o, Context context = null) public static string Pretty(this object o, Context context = null)
{ {
switch (o) { switch (o)
{
case null: return "null"; case null: return "null";
case Dictionary<string, string> d: case Dictionary<string, string> d:
var txt = ""; var txt = "";
foreach (var (k, v) in d) { foreach (var (k, v) in d)
{
txt += $"{k}={v};"; txt += $"{k}={v};";
} }
return $"{{{txt}}}"; return $"{{{txt}}}";
case Dictionary<string, List<string>> d: case Dictionary<string, List<string>> d:
var t = ""; var t = "";
foreach (var (k, v) in d) { foreach (var (k, v) in d)
{
var values = v.Pretty(); var values = v.Pretty();
if (!v.Any()) { if (!v.Any())
{
values = "*"; values = "*";
} }
@ -282,7 +358,7 @@ namespace AspectedRouting.Language.Functions
case object[] arr: case object[] arr:
return arr.ToList().Pretty(); return arr.ToList().Pretty();
case double[] arr: case double[] arr:
return arr.Select(d => (object) d).ToList().Pretty(); return arr.Select(d => (object)d).ToList().Pretty();
case string s: case string s:
return "\"" + s.Replace("\"", "\\\"") + "\""; return "\"" + s.Replace("\"", "\\\"") + "\"";
case IEnumerable<object> ls: case IEnumerable<object> ls:

1
AspectedRouting/Language/Functions/Dot.cs
View file

@ -36,6 +36,7 @@ namespace AspectedRouting.Language.Functions
{ {
if (arguments.Count() <= 2) if (arguments.Count() <= 2)
{ {
} }
var f0 = arguments[0]; var f0 = arguments[0];

4
AspectedRouting/Language/Functions/IfDotted.cs
View file

@ -1,6 +1,8 @@
using System;
using System.Collections.Generic; using System.Collections.Generic;
using AspectedRouting.Language.Expression; using AspectedRouting.Language.Expression;
using AspectedRouting.Language.Typ; using AspectedRouting.Language.Typ;
using Type = AspectedRouting.Language.Typ.Type;
namespace AspectedRouting.Language.Functions namespace AspectedRouting.Language.Functions
{ {
@ -11,7 +13,7 @@ namespace AspectedRouting.Language.Functions
public override string Description { get; } = "An if_then_else, but one which takes an extra argument and applies it on the condition, then and else.\n" + public override string Description { get; } = "An if_then_else, but one which takes an extra argument and applies it on the condition, then and else.\n" +
"Consider `fc`, `fthen` and `felse` are all functions taking an `a`, then:\n" + "Consider `fc`, `fthen` and `felse` are all functions taking an `a`, then:\n" +
"`(ifDotted fc fthen felse) a` === `(if (fc a) (fthen a) (felse a)" + "`(ifDotted fc fthen felse) a` === `(if (fc a) (fthen a) (felse a)`" +
"Selects either one of the branches, depending on the condition." + "Selects either one of the branches, depending on the condition." +
" The 'then' branch is returned if the condition returns the string `yes` or `true` or the boolean `true`" + " The 'then' branch is returned if the condition returns the string `yes` or `true` or the boolean `true`" +
"If the `else` branch is not set, `null` is returned in the condition is false." + "If the `else` branch is not set, `null` is returned in the condition is false." +

50
AspectedRouting/Language/Functions/IsNull.cs Normal file
View file

@ -0,0 +1,50 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using AspectedRouting.Language.Expression;
using AspectedRouting.Language.Typ;
using Type = AspectedRouting.Language.Typ.Type;
namespace AspectedRouting.Language.Functions
{
public class IsNull : Function
{
public override string Description { get; } = "Returns true if the given argument is null";
public override List<string> ArgNames { get; } = new List<string>{"a"};
public IsNull() : base("is_null", true,
new[]
{
new Curry(new Var("a"), Typs.Bool),
})
{
}
private IsNull(IEnumerable<Type> specializedTypes) : base("is_null", specializedTypes)
{
}
public override IExpression Specialize(IEnumerable<Type> allowedTypes)
{
var unified = Types.SpecializeTo(allowedTypes);
if (unified == null)
{
return null;
}
return new IsNull(unified);
}
public override object Evaluate(Context c, params IExpression[] arguments)
{
var arg = (string) arguments[0].Evaluate(c);
if (arg == null)
{
return "yes";
}
return "no";
}
}
}

18
AspectedRouting/Language/Functions/Mapping.cs
View file

@ -101,18 +101,18 @@ namespace AspectedRouting.Language.Functions
return resultFunction.Evaluate(c, otherARgs.ToArray()); return resultFunction.Evaluate(c, otherARgs.ToArray());
} }
public override IExpression Optimize() public override IExpression Optimize(out bool somethingChanged)
{ {
var optimizedFunctions = new Dictionary<string, IExpression>(); var optimizedFunctions = new Dictionary<string, IExpression>();
somethingChanged = false;
foreach (var (k, e) in StringToResultFunctions) foreach (var (k, e) in StringToResultFunctions)
{ {
var opt = e.Optimize(); var opt = e.Optimize(out var sc);
somethingChanged |= sc;
var typeOptStr = string.Join(";", opt.Types);
var typeEStr = string.Join("; ", e.Types);
if (!opt.Types.Any()) if (!opt.Types.Any())
{ {
var typeOptStr = string.Join(";", opt.Types);
var typeEStr = string.Join("; ", e.Types);
throw new NullReferenceException($"Optimized version is null, has different or empty types: " + throw new NullReferenceException($"Optimized version is null, has different or empty types: " +
$"\n{typeEStr}" + $"\n{typeEStr}" +
$"\n{typeOptStr}"); $"\n{typeOptStr}");
@ -121,7 +121,13 @@ namespace AspectedRouting.Language.Functions
optimizedFunctions[k] = opt; optimizedFunctions[k] = opt;
} }
if (!somethingChanged)
{
return this;
}
return new Mapping(optimizedFunctions); return new Mapping(optimizedFunctions);
} }
public static Mapping Construct(params (string key, IExpression e)[] exprs) public static Mapping Construct(params (string key, IExpression e)[] exprs)

25
AspectedRouting/Language/Functions/Parameter.cs
View file

@ -37,6 +37,11 @@ namespace AspectedRouting.Language.Functions
public IExpression Specialize(IEnumerable<Type> allowedTypes) public IExpression Specialize(IEnumerable<Type> allowedTypes)
{ {
/* var filtered = allowedTypes.Where(at => !(at is Curry));
if (filtered.Count() == 0)
{
return null;
}*/
var unified = Types.SpecializeTo(allowedTypes); var unified = Types.SpecializeTo(allowedTypes);
if (unified == null) if (unified == null)
{ {
@ -56,8 +61,9 @@ namespace AspectedRouting.Language.Functions
return new Parameter(passedTypes, this.ParamName); return new Parameter(passedTypes, this.ParamName);
} }
public IExpression Optimize() public IExpression Optimize(out bool somethingChanged)
{ {
somethingChanged = false;
return this; return this;
} }
@ -71,9 +77,26 @@ namespace AspectedRouting.Language.Functions
f(this); f(this);
} }
public bool Equals(IExpression other)
{
if (other is Parameter p)
{
return p.ParamName.Equals( this.ParamName);
}
return false;
}
public string Repr()
{
return "new Parameter(\"" + this.ParamName + "\")";
}
public override string ToString() public override string ToString()
{ {
return ParamName; return ParamName;
} }
} }
} }

20
AspectedRouting/Language/IExpression.cs
View file

@ -1,6 +1,7 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis; using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq; using System.Linq;
using AspectedRouting.Language.Functions; using AspectedRouting.Language.Functions;
using AspectedRouting.Language.Typ; using AspectedRouting.Language.Typ;
@ -31,20 +32,33 @@ namespace AspectedRouting.Language
/// Optimize a single expression, eventually recursively (e.g. a list can optimize all the contents) /// Optimize a single expression, eventually recursively (e.g. a list can optimize all the contents)
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
IExpression Optimize(); IExpression Optimize(out bool somethingChanged);
/// <summary> /// <summary>
/// Optimize with the given argument, e.g. listdot can become a list of applied arguments. /// Optimize with the given argument, e.g. listdot can become a list of applied arguments.
/// By default, this should return 'this.Apply(argument)'
/// </summary> /// </summary>
/// <param name="argument"></param> /// <param name="argument"></param>
/// <returns></returns> /// <returns></returns>
// IExpression OptimizeWithArgument(IExpression argument); // IExpression OptimizeWithArgument(IExpression argument);
void Visit(Func<IExpression, bool> f); void Visit(Func<IExpression, bool> f);
bool Equals(IExpression other);
/**
* Builds a string representation that can be used to paste into C# test programs
*/
string Repr();
} }
public static class ExpressionExtensions public static class ExpressionExtensions
{ {
public static void PrintRepr(this IExpression e)
{
Console.WriteLine(e.Repr()+"\n\n-----------\n");
}
public static object Run(this IExpression e, Context c, Dictionary<string, string> tags) public static object Run(this IExpression e, Context c, Dictionary<string, string> tags)
{ {
try { try {
@ -111,7 +125,7 @@ namespace AspectedRouting.Language
foreach (var expr in exprs) { foreach (var expr in exprs) {
if (specializedTypes == null) { if (specializedTypes == null) {
specializedTypes = expr.Types; specializedTypes = expr.Types; // This is t
} }
else { else {
var newlySpecialized = Typs.WidestCommonTypes(specializedTypes, expr.Types); var newlySpecialized = Typs.WidestCommonTypes(specializedTypes, expr.Types);

16
AspectedRouting/Program.cs
View file

@ -165,10 +165,18 @@ namespace AspectedRouting
continue; continue;
} }
var strSplit = str.Split("="); try
var k = strSplit[0].Trim(); {
var v = strSplit[1].Trim();
tags[k] = v; var strSplit = str.Split("=");
var k = strSplit[0].Trim();
var v = strSplit[1].Trim();
tags[k] = v;
}
catch (Exception e)
{
Console.Error.WriteLine("Could not parse tag: "+str);
}
} }
try { try {

4
AspectedRouting/Tests/ProfileTestSuite.cs
View file

@ -184,11 +184,11 @@ namespace AspectedRouting.Tests
} }
if (actual.Priority >= 100 || actual.Priority <= -100) if (actual.Priority >= 100 || actual.Priority <= -100)
{ {/*
Err($"priority is not within range of -100 and +100. This is needed due to a bug in Itinero2.0, see https://github.com/itinero/routing2/issues/30", Err($"priority is not within range of -100 and +100. This is needed due to a bug in Itinero2.0, see https://github.com/itinero/routing2/issues/30",
actual.Priority + " < 100 && -100 < "+actual.Priority, actual.Priority + " < 100 && -100 < "+actual.Priority,
actual.Priority); actual.Priority);
success = false; success = false;*/
} }