From 31dbe188f08b2165dd094a0888c8c62c81d1027d Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Wed, 26 Aug 2020 00:03:15 +0000 Subject: [PATCH] Factor out some of the common parts of the grammar --- DefaultGrammar.cs | 10 ++- Lexer.cs | 10 +-- LexerGenerator.cs | 2 + MixFix.cs | 166 +++++++++++++++++++++++++++++---------------- MixFixGenerator.cs | 3 +- Parser.cs | 8 ++- Utils/ToString.cs | 7 +- 7 files changed, 136 insertions(+), 70 deletions(-) diff --git a/DefaultGrammar.cs b/DefaultGrammar.cs index 0a7face..b62e221 100644 --- a/DefaultGrammar.cs +++ b/DefaultGrammar.cs @@ -8,7 +8,13 @@ public static class DefaultGrammar { public static PrecedenceDAG DefaultPrecedenceDAG = EmptyPrecedenceDAG .WithOperator("bool", NonAssociative, "equality|terminal", S.And, "equality|terminal") - .WithOperator("equality", NonAssociative, "int", S.Eq, "int") + .WithOperator("equality", NonAssociative, "int|terminal|additive|multiplicative", S.Eq, "int|terminal|additive|multiplicative") .WithOperator("int", NonAssociative, S.Int) - .WithOperator("terminal", NonAssociative, S.Ident); + .WithOperator("additive", LeftAssociative, "int|terminal|multiplicative", S.Plus, "int|terminal|multiplicative") +// .WithOperator("multiplicative", LeftAssociative, "int|terminal", S.Times, "int|terminal") + .WithOperator("terminal", NonAssociative, S.Ident) + // This is the root set of operators + .WithOperator("program", NonAssociative, + // "bool" // TODO: this needs aliases + "equality|terminal", S.And, "equality|terminal"); } \ No newline at end of file diff --git a/Lexer.cs b/Lexer.cs index 2dd0c30..bb04460 100644 --- a/Lexer.cs +++ b/Lexer.cs @@ -63,10 +63,12 @@ public static partial class Lexer { Rule(S.Space, C.SpaceSeparator, S.Space), Rule(S.Space, EOF, S.End), Rule(S.Space, '"', S.StringOpen, S.String), - Rule(S.Space, new[]{'='}, S.Eq), - Rule(S.Eq, new[]{'='}, S.Eq, S.Space), - Rule(S.Space, new[]{'&'}, S.And), - Rule(S.And, new[]{'&'}, S.And, S.Space), + Rule(S.Space, '=', S.Eq), + Rule(S.Eq, '=', S.Eq, S.Space), + Rule(S.Space, '&', S.And), + Rule(S.And, '&', S.And, S.Space), + Rule(S.Space, '+', S.Plus, S.Space), + Rule(S.Space, '*', S.Times, S.Space), // TODO: https://unicode.org/reports/tr31/#D1 has a lot to say about // identifiers Rule(S.Space, C.LowercaseLetter, S.Ident), diff --git a/LexerGenerator.cs b/LexerGenerator.cs index 5d50d35..b5dc2e0 100644 --- a/LexerGenerator.cs +++ b/LexerGenerator.cs @@ -16,6 +16,8 @@ public static class LexerGenerator { Case("Decimal"), Case("Ident"), Case("And"), + Case("Plus"), + Case("Times"), Case("Eq"), Case("Space"), Case("String"), diff --git a/MixFix.cs b/MixFix.cs index 7273c52..f86e73d 100644 --- a/MixFix.cs +++ b/MixFix.cs @@ -13,19 +13,83 @@ using Hole = System.Collections.Immutable.ImmutableHashSet< using static Global; using static MixFix.Fixity; -public class Foo { - public string v; - public static implicit operator Foo(string s) => new Foo{v=s}; - public static Foo operator |(Foo a, string b) => a.v + b; -} - public static partial class MixFix { public partial class Grammar { - public static Grammar Sequence(params Grammar[] xs) - => Grammar.Sequence(xs.ToImmutableList()); + public static Grammar Sequence(params Grammar[] xs) { + var filteredXs = xs.Where(x => !x.IsEmpty); + if (filteredXs.Count() == 1) { + return filteredXs.Single().ElseThrow(() => new Exception("TODO: use an either to prove that this is safe.")); + } else { + return Grammar.Sequence(filteredXs); + } + } public static Grammar Or(params Grammar[] xs) - => Grammar.Or(xs.ToImmutableList()); + => OrCleaned(xs.ToImmutableList()); + + // TODO: instead hide the default constructor for Or. + public static Grammar OrCleaned(IEnumerable xs) { + var filteredXs = xs.Where(x => !x.IsEmpty); + if (filteredXs.Count() == 1) { + return filteredXs.Single().ElseThrow(() => new Exception("TODO: use an either to prove that this is safe.")); + } else { + return Grammar.Or(filteredXs); + } + } + + public static Grammar Empty = Or(); + + public bool IsEmpty { + get => this.Match( + Or: l => l.Count() == 0, + Sequence: l => l.Count() == 0, + RepeatOnePlus: g => g.IsEmpty, + Terminal: t => false, + Rule: r => false + ); + } + + public static Grammar operator |(Grammar a, Grammar b) + => Or(a, b); + + public static implicit operator Grammar((Grammar a, Grammar b) gs) + => Sequence(gs.a, gs.b); + + public static implicit operator Grammar((Grammar a, Grammar b, Grammar c) gs) + => Sequence(gs.a, gs.b, gs.c); + + public static bool operator true(Grammar g) => !g.IsEmpty; + public static bool operator false(Grammar g) => g.IsEmpty; + + public Grammar this[string multiplicity] { + get { + if (multiplicity != "+") { + throw new Exception("Unexpected multiplicity"); + } else { + if (this.IsEmpty) { + return Or(); + } else { + return RepeatOnePlus(this); + } + } + } + } + + private string Paren(bool paren, string s) + => paren ? $"({s})" : s; + + string CustomToString() + => this.Match( + Or: l => l.Count() == 0 + ? "Or(Empty)" + : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")), + Sequence: l => l.Count() == 0 + ? "Sequence(Empty)" + : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(",")), + RepeatOnePlus: g => $"({g.Str()})+", + Terminal: t => t.Str(), + Rule: r => r + ); } public partial class Operator { @@ -126,11 +190,13 @@ public static partial class MixFix { } // TODO: cache this for improved complexity + // TODO: find a better name public ImmutableHashSet leftmostHole_ { get => leftmostHole.Else(ImmutableHashSet.Empty); } // TODO: cache this for improved complexity + // TODO: find a better name public ImmutableHashSet rightmostHole_ { get => rightmostHole.Else(ImmutableHashSet.Empty); } @@ -243,67 +309,47 @@ public static partial class MixFix { associativity: associativity, parts: parts.ToImmutableList())); - public static Grammar HoleToGrammar(PrecedenceDAG precedenceDAG, Hole precedenceGroups) - => Grammar.Or( - precedenceGroups.Select(precedenceGroup => - DAGNodeToGrammar(precedenceDAG, precedenceDAG[precedenceGroup]))); + public static Grammar ToGrammar(this Hole precedenceGroups) + => Grammar.OrCleaned( + precedenceGroups.Select(precedenceGroup => + Grammar.Rule(precedenceGroup))); - public static Grammar PartToGrammar(PrecedenceDAG precedenceDAG, Part part) + public static Grammar ToGrammar(this Part part) => part.Match( Name: name => Grammar.Terminal(name), - Hole: precedenceGroups => HoleToGrammar(precedenceDAG, precedenceGroups)); + Hole: precedenceGroups => precedenceGroups.ToGrammar()); - public static Grammar OperatorToGrammar(PrecedenceDAG precedenceDAG, Operator @operator) + public static Grammar ToGrammar(this Operator @operator) => Grammar.Sequence( - @operator.internalParts.Select( - part => PartToGrammar(precedenceDAG, part))); + @operator.internalParts.Select(part => part.ToGrammar())); - 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 + public static Grammar ToGrammar(this IEnumerable operators) + => Grammar.OrCleaned( + operators.Select(@operator => @operator.ToGrammar())); + public static Grammar ToGrammar(this DAGNode node) { + var lsucc = node.leftmostHole_.ToGrammar(); + var rsucc = node.rightmostHole_.ToGrammar(); + var closed = node.closed.ToGrammar(); + var nonAssoc = node.infixNonAssociative.ToGrammar(); + var prefix = node.prefix.ToGrammar(); + var postfix = node.postfix.ToGrammar(); + var infixl = node.infixLeftAssociative.ToGrammar(); + var infixr = node.infixRightAssociative.ToGrammar(); + // TODO: BUG: only include these parts if there are + // any operators with that fixity. + return + closed + | (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar.Empty) // 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)+ - - + | ((prefix || infixr) ? ((prefix | (lsucc, infixr))["+"], rsucc) : Grammar.Empty) // 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(); + | ((postfix || infixl) ? (lsucc, (postfix | (infixl, rsucc))["+"]) : Grammar.Empty); } - public static void DAGToGrammar(PrecedenceDAG precedenceDAG) { - - } - - public static void RecursiveDescent(IEnumerable e) { - - } + public static ImmutableDictionary DAGToGrammar(PrecedenceDAG precedenceDAG) + => precedenceDAG.ToImmutableDictionary( + node => node.Key, + node => node.Value.ToGrammar()); } \ No newline at end of file diff --git a/MixFixGenerator.cs b/MixFixGenerator.cs index d9ace9f..96d1db0 100644 --- a/MixFixGenerator.cs +++ b/MixFixGenerator.cs @@ -16,7 +16,8 @@ public static class ParserGenerator { Case("Grammar", "RepeatOnePlus"), Case("IEnumerable", "Or"), Case("IEnumerable", "Sequence"), - Case("S", "Terminal")), + Case("S", "Terminal"), + Case("string", "Rule")), Variant("Fixity", Case("Closed"), diff --git a/Parser.cs b/Parser.cs index 30431ca..3b6f7d5 100644 --- a/Parser.cs +++ b/Parser.cs @@ -10,7 +10,7 @@ using static Global; public static partial class Parser { public static Ast.Expr Parse(string source) { - Log(DefaultGrammar.DefaultPrecedenceDAG.ToString()); + Log(MixFix.DAGToGrammar(DefaultGrammar.DefaultPrecedenceDAG).Str()); return Lexer.Lex(source) .SelectMany(lexeme => lexeme.state.Match( @@ -18,6 +18,8 @@ public static partial class Parser { String: () => Ast.Expr.String(lexeme.lexeme).Singleton(), Ident: () => Enumerable.Empty(), // TODO And: () => Enumerable.Empty(), // TODO + Plus: () => Enumerable.Empty(), // TODO + Times: () => Enumerable.Empty(), // TODO Space: () => Enumerable.Empty(), // ignore Eq: () => Enumerable.Empty(), // TODO End: () => Enumerable.Empty(), // TODO @@ -30,6 +32,10 @@ public static partial class Parser { .ElseThrow(() => new ParserErrorException( "empty file or more than one expression in file.")); } + + public static void RecursiveDescent(IEnumerable e) { + + } } // Notes: diff --git a/Utils/ToString.cs b/Utils/ToString.cs index 5fcc142..2fac8b1 100644 --- a/Utils/ToString.cs +++ b/Utils/ToString.cs @@ -22,8 +22,11 @@ public static class ToStringImplementations { public static string Str(this ImmutableList l) => $"ImmutableList({l.Select(x => x.Str()).JoinWith(", ")})"; - public static string Str(this ImmutableHashSet h) - => $"ImmutableHashSet({h.Select(x => x.Str()).JoinWith(", ")})"; + public static string Str(this ImmutableHashSet h) + => $"ImmutableHashSet({h.Select(x => x.Str()).JoinWith(", ")})"; + + public static string Str(this ImmutableDictionary h) + => $"ImmutableDictionary(\n{h.Select(x => $" {x.Key.Str()}:{x.Value.Str()}").JoinWith(",\n")}\n)"; public static string Str(this string s) => $"\"{s}\"";