From 6d5d0dd00b15b59c891f368e15a6216300de941d Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Mon, 24 Aug 2020 02:40:36 +0000 Subject: [PATCH] Generate grammar from precedence DAG --- MixFix.cs | 101 +++++++++++++++++++++++++++++------ MixFixGenerator.cs | 9 ++-- Utils/Enumerable.cs | 25 +++++++++ Utils/Immutable/Option.cs | 3 ++ Utils/OverridableToString.cs | 0 5 files changed, 119 insertions(+), 19 deletions(-) delete mode 100644 Utils/OverridableToString.cs diff --git a/MixFix.cs b/MixFix.cs index 07f74c4..7273c52 100644 --- a/MixFix.cs +++ b/MixFix.cs @@ -20,6 +20,14 @@ public class Foo { } public static partial class MixFix { + public partial class Grammar { + public static Grammar Sequence(params Grammar[] xs) + => Grammar.Sequence(xs.ToImmutableList()); + + public static Grammar Or(params Grammar[] xs) + => Grammar.Or(xs.ToImmutableList()); + } + public partial class Operator { private string CustomToString() => $"Operator(\"{precedenceGroup}\", {fixity}, {parts.Select(x => x.Match(Hole: h => h.Select(g => g.ToString()).JoinWith("|"), Name: n => $"\"{n}\"")).JoinWith(", ")})"; @@ -48,6 +56,12 @@ public static partial class MixFix { get => parts.Last().Bind(lastPart => lastPart.AsHole); } + // TODO: does this need any caching? + public IEnumerable internalParts { + get => parts.SkipWhile(part => part.IsHole) + .SkipLastWhile(part => part.IsHole); + } + private static Func error = () => throw new Exception("Internal error: unexpected fixity."); @@ -110,6 +124,16 @@ public static partial class MixFix { public Option> rightmostHole { get => allOperators.First(@operator => @operator.rightmostHole); } + + // TODO: cache this for improved complexity + public ImmutableHashSet leftmostHole_ { + get => leftmostHole.Else(ImmutableHashSet.Empty); + } + + // TODO: cache this for improved complexity + public ImmutableHashSet rightmostHole_ { + get => rightmostHole.Else(ImmutableHashSet.Empty); + } } public static DAGNode EmptyDAGNode = new DAGNode( @@ -145,7 +169,7 @@ public static partial class MixFix { existing.IfSome(existingHole => @new.IfSome(newHole => { if (! newHole.SetEquals(existingHole)) { - throw new ParserExtensionException($"Cannot extend parser with operator {@operator}, its {name} hole ({newHole.ToString()}) must either be empty or else use the same precedence groups as the existing operators in {@operator.precedenceGroup}, i.e. {existingHole}."); + throw new ParserExtensionException($"Cannot extend parser with operator {@operator}, its {name} hole ({newHole.ToString()}) must either be absent or else use the same precedence groups as the existing operators in {@operator.precedenceGroup}, i.e. {existingHole}."); } return unit; }) @@ -184,7 +208,7 @@ public static partial class MixFix { } public static void CheckSingleUseOfNames(PrecedenceDAG precedenceDAG, Operator @operator) { - // TODO: check that each name part isn't used elsewhere in a way that could cause ambiguity (use in a different namespace which is bracketed is okay, etc.). Probably something to do with paths reachable from the root. + // TODO: check that each name part isn't used elsewhere in a way that adding this operator would could cause ambiguity (use in a different namespace which is bracketed is okay, etc.). Probably something to do with paths reachable from the root. } public static void CheckNotAlias(PrecedenceDAG precedenceDAG, Operator @operator) { @@ -193,6 +217,10 @@ public static partial class MixFix { } } + public static void CheckAcyclic(PrecedenceDAG precedenceDAG, Operator @operator) { + // TODO: check that the DAG stays acyclic after adding this operator + } + public static PrecedenceDAG With(this PrecedenceDAG precedenceDAG, Operator @operator) { // This is where all the checks are done to ensure that the // resulting grammar is well-formed and assuredly unambiguous. @@ -204,6 +232,7 @@ public static partial class MixFix { CheckConsecutiveHoles(precedenceDAG, @operator); CheckSingleUseOfNames(precedenceDAG, @operator); CheckNotAlias(precedenceDAG, @operator); + CheckAcyclic(precedenceDAG, @operator); return precedenceDAG.lens[@operator.precedenceGroup].Add(@operator); } @@ -214,23 +243,63 @@ public static partial class MixFix { associativity: associativity, parts: parts.ToImmutableList())); - public static Grammar OperatorToGrammar(Operator @operator) { - //@operator. + public static Grammar HoleToGrammar(PrecedenceDAG precedenceDAG, Hole precedenceGroups) + => Grammar.Or( + precedenceGroups.Select(precedenceGroup => + DAGNodeToGrammar(precedenceDAG, precedenceDAG[precedenceGroup]))); + + public static Grammar PartToGrammar(PrecedenceDAG precedenceDAG, Part part) + => part.Match( + Name: name => Grammar.Terminal(name), + Hole: precedenceGroups => HoleToGrammar(precedenceDAG, precedenceGroups)); + + public static Grammar OperatorToGrammar(PrecedenceDAG precedenceDAG, Operator @operator) + => Grammar.Sequence( + @operator.internalParts.Select( + part => PartToGrammar(precedenceDAG, part))); + + public static Grammar OperatorsToGrammar(PrecedenceDAG precedenceDAG, IEnumerable operators) + => Grammar.Or( + operators.Select(@operator => + OperatorToGrammar(precedenceDAG, @operator))); + + public static Grammar DAGNodeToGrammar(PrecedenceDAG precedenceDAG, DAGNode node) { + return Grammar.Or(ImmutableList( + OperatorsToGrammar(precedenceDAG, node.closed), + // successor_left nonassoc successor_right + Grammar.Sequence( + HoleToGrammar(precedenceDAG, node.leftmostHole_), + OperatorsToGrammar(precedenceDAG, node.infixNonAssociative), + HoleToGrammar(precedenceDAG, node.rightmostHole_)), + // (prefix | successor_left leftassoc)+ successor_right + + + // TODO: post-processsing of the leftassoc list. + Grammar.Sequence( + Grammar.RepeatOnePlus( + Grammar.Or( + OperatorsToGrammar(precedenceDAG, node.prefix), + Grammar.Sequence( + HoleToGrammar(precedenceDAG, node.leftmostHole_), + OperatorsToGrammar(precedenceDAG, node.infixRightAssociative)))), + HoleToGrammar(precedenceDAG, node.rightmostHole_)), + // successor_left (posftix | leftassoc successor_right)+ + + + // TODO: post-processsing of the leftassoc list. + Grammar.Sequence( + HoleToGrammar(precedenceDAG, node.leftmostHole_), + Grammar.RepeatOnePlus( + Grammar.Or( + OperatorsToGrammar(precedenceDAG, node.postfix), + Grammar.Sequence( + OperatorsToGrammar(precedenceDAG, node.infixLeftAssociative), + HoleToGrammar(precedenceDAG, node.rightmostHole_))))) + )); throw new NotImplementedException(); } - public static Grammar DAGNodeToGrammar(DAGNode node) { -// return Grammar.Or(ImmutableList( -// node.closed -// closed, -// succl nonassoc succr, -// (prefix | succl rightassoc)+ succr, -// succl (suffix | succr rightassoc)+ -// )); - throw new NotImplementedException(); - } - - public static void DAGToGrammar(DAGNode precedenceDAG) { + public static void DAGToGrammar(PrecedenceDAG precedenceDAG) { } diff --git a/MixFixGenerator.cs b/MixFixGenerator.cs index 964f6a4..d9ace9f 100644 --- a/MixFixGenerator.cs +++ b/MixFixGenerator.cs @@ -4,7 +4,8 @@ public static class ParserGenerator { public static void Main() { Generate( "MixFixGenerated.cs", - "using System.Collections.Immutable;\n" + "using System.Collections.Generic;\n" + + "using System.Collections.Immutable;\n" + "using S = Lexer.S;\n" + "using PrecedenceGroupName = System.String;", "public static partial class MixFix {", @@ -12,8 +13,10 @@ public static class ParserGenerator { "MixFix.", Types( Variant("Grammar", - Case("ImmutableList", "Or"), - Case("ImmutableList", "Sequence")), + Case("Grammar", "RepeatOnePlus"), + Case("IEnumerable", "Or"), + Case("IEnumerable", "Sequence"), + Case("S", "Terminal")), Variant("Fixity", Case("Closed"), diff --git a/Utils/Enumerable.cs b/Utils/Enumerable.cs index d119cc3..6dfbf07 100644 --- a/Utils/Enumerable.cs +++ b/Utils/Enumerable.cs @@ -210,4 +210,29 @@ public static class Collection { public static bool SetEquals(this ImmutableHashSet a, ImmutableHashSet b) => a.All(x => b.Contains(x)) && b.All(x => a.Contains(x)); + + public static (Option firstElement, ImmutableQueue rest) Dequeue(this ImmutableQueue q) { + if (q.IsEmpty) { + return (Option.None(), q); + } else { + T firstElement; + var rest = q.Dequeue(out firstElement); + return (firstElement.Some(), rest); + } + } + + public static IEnumerable SkipLastWhile(this IEnumerable e, Func predicate) { + var pending = ImmutableQueue.Empty; + foreach (var x in e) { + if (predicate(x)) { + pending = pending.Enqueue(x); + } else { + while (!pending.IsEmpty) { + yield return pending.Peek(); + pending = pending.Dequeue(); + } + yield return x; + } + } + } } \ No newline at end of file diff --git a/Utils/Immutable/Option.cs b/Utils/Immutable/Option.cs index 847a8da..8a2d7e3 100644 --- a/Utils/Immutable/Option.cs +++ b/Utils/Immutable/Option.cs @@ -67,6 +67,9 @@ namespace Immutable { public static T Else(this Option o, Func none) => o.Match_(some => some, none); + public static T Else(this Option o, T none) + => o.Match_(some => some, () => none); + public static Option Else(this Option o, Func> none) => o.Match_(value => value.Some(), none); diff --git a/Utils/OverridableToString.cs b/Utils/OverridableToString.cs deleted file mode 100644 index e69de29..0000000