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

Factor out some of the common parts of the grammar

Browse Source
This commit is contained in:
Suzanne Soy 2020-08-26 00:03:15 +00:00
parent 6d5d0dd00b
commit 31dbe188f0
7 changed files with 136 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
DefaultGrammar.cs
View File

@ -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");
}

10
Lexer.cs
View File

@ -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),

2
LexerGenerator.cs
View File

@ -16,6 +16,8 @@ public static class LexerGenerator {
Case("Decimal"),
Case("Ident"),
Case("And"),
Case("Plus"),
Case("Times"),
Case("Eq"),
Case("Space"),
Case("String"),

166
MixFix.cs
View File

@ -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<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.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<string>(
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<string> leftmostHole_ {
get => leftmostHole.Else(ImmutableHashSet<string>.Empty);
}
// TODO: cache this for improved complexity
// TODO: find a better name
public ImmutableHashSet<string> rightmostHole_ {
get => rightmostHole.Else(ImmutableHashSet<string>.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<Operator> operators)
=> Grammar.Or(
operators.Select(@operator =>
OperatorToGrammar(precedenceDAG, @operator)));
public static Grammar DAGNodeToGrammar(PrecedenceDAG precedenceDAG, DAGNode node) {
return Grammar.Or(ImmutableList<Grammar>(
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<Operator> 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<Lexeme> e) {
}
public static ImmutableDictionary<string, Grammar> DAGToGrammar(PrecedenceDAG precedenceDAG)
=> precedenceDAG.ToImmutableDictionary(
node => node.Key,
node => node.Value.ToGrammar());
}

3
MixFixGenerator.cs
View File

@ -16,7 +16,8 @@ public static class ParserGenerator {
Case("Grammar", "RepeatOnePlus"),
Case("IEnumerable<Grammar>", "Or"),
Case("IEnumerable<Grammar>", "Sequence"),
Case("S", "Terminal")),
Case("S", "Terminal"),
Case("string", "Rule")),
Variant("Fixity",
Case("Closed"),

8
Parser.cs
View File

@ -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<Ast.Expr>(), // TODO
And: () => Enumerable.Empty<Ast.Expr>(), // TODO
Plus: () => Enumerable.Empty<Ast.Expr>(), // TODO
Times: () => Enumerable.Empty<Ast.Expr>(), // TODO
Space: () => Enumerable.Empty<Ast.Expr>(), // ignore
Eq: () => Enumerable.Empty<Ast.Expr>(), // TODO
End: () => Enumerable.Empty<Ast.Expr>(), // 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<Lexeme> e) {
}
}
// Notes:

7
Utils/ToString.cs
View File

@ -22,8 +22,11 @@ public static class ToStringImplementations {
public static string Str<T>(this ImmutableList<MixFix.Part> l)
=> $"ImmutableList({l.Select(x => x.Str()).JoinWith(", ")})";
public static string Str<T>(this ImmutableHashSet<String> h)
=> $"ImmutableHashSet({h.Select(x => x.Str<String>()).JoinWith(", ")})";
public static string Str<T>(this ImmutableHashSet<string> h)
=> $"ImmutableHashSet({h.Select(x => x.Str<string>()).JoinWith(", ")})";
public static string Str<Grammar>(this ImmutableDictionary<string,Grammar> h)
=> $"ImmutableDictionary(\n{h.Select(x => $" {x.Key.Str<string>()}:{x.Value.Str<Grammar>()}").JoinWith(",\n")}\n)";
public static string Str<T>(this string s) => $"\"{s}\"";