suzanne.soy/envlang-csharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed bug: an empty or is not vacuously .IsEmpty

Browse Source
This commit is contained in:
Suzanne Soy 2020-08-31 15:26:53 +00:00
parent 74c3abcccc
commit 89c9908957
4 changed files with 37 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
DefaultGrammar.cs
View File

@ -7,11 +7,11 @@ using static MixFix.Associativity;
public static class DefaultGrammar {
public static PrecedenceDAG DefaultPrecedenceDAG
= EmptyPrecedenceDAG
.WithOperator("bool", NonAssociative, "equality|terminal", S.And, "equality|terminal")
/*.WithOperator("bool", NonAssociative, "equality|terminal", S.And, "equality|terminal")
.WithOperator("equality", NonAssociative, "int|terminal|additive|multiplicative", S.Eq, "int|terminal|additive|multiplicative")
.WithOperator("int", NonAssociative, S.Int)
.WithOperator("additive", LeftAssociative, "int|terminal|multiplicative", S.Plus, "int|terminal|multiplicative")
.WithOperator("multiplicative", LeftAssociative, "int|terminal", S.Times, "int|terminal")
.WithOperator("multiplicative", LeftAssociative, "int|terminal", S.Times, "int|terminal")*/
.WithOperator("terminal", NonAssociative, S.Ident)
// This is the root set of operators
.WithOperator("program", NonAssociative,

50
MixFix.cs
View File

@ -68,10 +68,12 @@ public static partial class MixFix {
public bool IsEmpty {
get => this.Match(
Or: l => l.All(g => g.IsEmpty),
Or: l => l.Count() > 0 && l.All(g => g.IsEmpty),
Sequence: l => l.All(g => g.IsEmpty),
RepeatOnePlus: g => g.IsEmpty,
Terminal: t => false,
Annotated: a => a.Item2.IsEmpty,
// TODO: when converting to Grammar2, make sure to recompute the .IsEmpty and .IsImpossible and .AllowsEmpty
Rule: r => false
);
}
@ -79,12 +81,13 @@ public static partial class MixFix {
// TODO: cache this!
public bool AllowsEmpty {
get => this.Match(
Or: l => l.Any(g => g.AllowsEmpty),
Or: l => l.Count() > 0 && l.Any(g => g.AllowsEmpty),
Sequence: l => l.All(g => g.IsEmpty),
// This one should not be true, if it is
// then the precedence graph may be ill-formed?
RepeatOnePlus: g => g.AllowsEmpty,
Terminal: t => false,
Annotated: a => a.Item2.AllowsEmpty,
Rule: r => false
);
}
@ -95,6 +98,7 @@ public static partial class MixFix {
Sequence: l => l.Any(g => g.IsImpossible),
RepeatOnePlus: g => g.IsImpossible,
Terminal: t => false,
Annotated: a => a.Item2.IsImpossible,
Rule: r => false
);
}
@ -128,16 +132,19 @@ public static partial class MixFix {
private string Paren(bool paren, string s)
=> paren ? $"({s})" : s;
string CustomToString() =>
this.IsEmpty ? "Empty"
: this.IsImpossible ? "Impossible"
: this.Match<string>(
string CustomToString()
=> this.Match<string>(
Or: l =>
Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
l.Count() == 0
? "ImpossibleOr"
: Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
Sequence: l =>
Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
l.Count() == 0
? "EmptySequence"
: Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
RepeatOnePlus: g => $"{g.Str()}+",
Terminal: t => t.Str(),
Annotated: a => $"{a.Item1}: {a.Item2}",
Rule: r => r
);
}
@ -164,14 +171,16 @@ public static partial class MixFix {
private string Paren(bool paren, string s)
=> paren ? $"({s})" : s;
string CustomToString() =>
this.IsEmpty ? "Empty"
: this.IsImpossible ? "Impossible"
: this.Match<string>(
string CustomToString()
=> this.Match<string>(
Or: l =>
Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
l.Count() == 0
? "ImpossibleOr"
: Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
Sequence: l =>
Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
l.Count() == 0
? "EmptySequence"
: Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
RepeatOnePlus: g => $"{g.Str()}+",
Terminal: t => t.Str()
);
@ -423,8 +432,6 @@ public static partial class MixFix {
var infixr = node.infixRightAssociative.ToGrammar1();
//Log("closed.IsImpossible:"+closed.IsImpossible);
@ -434,15 +441,15 @@ public static partial class MixFix {
// they are empty.
Func<string, Grammar1, Grammar1> Annotated = (s, g) => Grammar1.Annotated((s, g));
return
(closed ? closed : Grammar1.Impossible)
| (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar1.Impossible)
Annotated("closed", closed ? closed : Grammar1.Impossible)
| Annotated("nonAssoc", (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar1.Impossible))
// TODO: post-processsing of the rightassoc list.
| ((prefix || infixr) ? ((prefix || (lsucc, infixr))["+"], rsucc) : Grammar1.Impossible)
| Annotated("prefix||infixr", ((prefix || infixr) ? ((prefix || (lsucc, infixr))["+"], rsucc) : Grammar1.Impossible))
// TODO: post-processsing of the leftassoc list.
| ((postfix || infixl) ? (lsucc, (postfix || (infixl, rsucc))["+"]) : Grammar1.Impossible);
| Annotated("postfix||infixl", ((postfix || infixl) ? (lsucc, (postfix || (infixl, rsucc))["+"]) : Grammar1.Impossible));
}
public static EquatableDictionary<string, Grammar1> ToGrammar1(this PrecedenceDAG precedenceDAG)
@ -462,6 +469,7 @@ public static partial class MixFix {
}
return recur(labeled[r], labeled);
},
Annotated: a => recur(a.Item2, labeled),
Terminal: t => Grammar2.Terminal(t),
Sequence: l => Grammar2.Sequence(l.Select(g => recur(g, labeled))),
Or: l => Grammar2.Or(l.Select(g => recur(g, labeled))),

1
MixFixGenerator.cs
View File

@ -20,6 +20,7 @@ public static class ParserGenerator {
Case("IEnumerable<Grammar1>", "Or"),
Case("IEnumerable<Grammar1>", "Sequence"),
Case("S", "Terminal"),
Case("ValueTuple<string, Grammar1>", "Annotated"),
Case("string", "Rule")),
Variant("Grammar2",

5
Utils/Global.cs
View File

@ -11,6 +11,11 @@ public static class Global {
public static void Log (string str) => Console.WriteLine(str);
public static T Log<T>(string str, Func<T> f) {
Console.WriteLine(str);
return f();
}
public static Unit unit { get => Unit.unit; }
public static Option<T> None<T>() => Option.None<T>();