diff --git a/.gitignore b/.gitignore index f9443e5..b489d32 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ /tests_results /main.exe /*Generated.cs -/*Generator.exe +/*Generator.exe \ No newline at end of file diff --git a/Lexer.cs b/Lexer.cs index ed5c4d5..c5fd0f7 100644 --- a/Lexer.cs +++ b/Lexer.cs @@ -72,7 +72,7 @@ public static partial class Lexer { Rule(S.String, '"', S.StringClose, S.Space), }; - public static Dictionary> Dict = + public static DefaultDictionary> Dict = Default .GroupBy(r => r.oldState, r => r) .ToDefaultDictionary( @@ -81,7 +81,7 @@ public static partial class Lexer { rs => rs.ToList()) ; // This adds transitions through an implicit empty whitespace. - public static Dictionary> WithEpsilonTransitions = + public static DefaultDictionary> WithEpsilonTransitions = Dict.ToDefaultDictionary( new List(), kv => kv.Key, diff --git a/Makefile b/Makefile index 431e621..03e77ed 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ run: main.exe mono main.exe main.exe: $(sort $(CS) $(GENERATED)) - mcs -out:$@ $^ + mcs -out:$@ /reference:/usr/lib/mono/fsharp/FSharp.Core.dll $^ %Generated.cs: .%Generator.exe mono $< diff --git a/Parser.cs b/Parser.cs index 7f6c6c9..aeb860c 100644 --- a/Parser.cs +++ b/Parser.cs @@ -12,8 +12,24 @@ public static partial class Parser { public static PrecedenceDAG DefaultPrecedenceDAG = new PrecedenceDAG(); - public static PrecedenceDAG With(PrecedenceDAG precedenceDAG, Operator @operator) { + public static DAGNode With(DAGNode node, Operator op) { +/* var newOp = op.fixity.Match( + Closed: () => node.WithClosed(op), + InfixLeftAssociative: () => node.WithInfixLeftAssociative(op), + InfixRightAssociative: () => node.WithInfixRightAssociative(op), + InfixNonAssociative: () => node.WithInfixNonAssociative(op), + Prefix: () => node.WithPrefix(op), + Postfix: () => node.WithPostFix(op), + Terminal: () => node.WithTerminal(op) + );*/ + // op.fixity, parts, holes + throw new NotImplementedException(); + } + public static PrecedenceDAG With(PrecedenceDAG precedenceDAG, Operator @operator) { + /*precedenceDAG.update( + dagNode => dagNode.Add(@operator) + );*/ throw new NotImplementedException(); } diff --git a/ParserGenerator.cs b/ParserGenerator.cs index 0536f9d..2c496b3 100644 --- a/ParserGenerator.cs +++ b/ParserGenerator.cs @@ -24,21 +24,18 @@ public static class ParserGenerator { Case("Terminal")), Record("Operator", - Field("List", "Parts"), - Field("List", "Holes")), - - Record("Closed", - Field("S", "openSymbol"), - Field("S", "closedSymbol")), + Field("Fixity", "fixity"), + Field("List", "parts"), + Field("List", "holes")), Record("DAGNode", - Field("List", "infixLeftAssociative"), - Field("List", "infixRightAssociative"), - Field("List", "infixNonAssociative"), - Field("List", "prefix"), - Field("List", "postfix"), - Field("List", "closed"), - Field("List", "terminal"), - Field("List", "successors")))); + Field("List", "infixLeftAssociative"), + Field("List", "infixRightAssociative"), + Field("List", "infixNonAssociative"), + Field("List", "prefix"), + Field("List", "postfix"), + Field("List", "closed"), + Field("List", "terminal"), + Field("List", "successorNodes")))); } } \ No newline at end of file diff --git a/T4/Generator.cs b/T4/Generator.cs index 871edfc..4fa36a3 100644 --- a/T4/Generator.cs +++ b/T4/Generator.cs @@ -16,7 +16,7 @@ public static class Generator { o.WriteLine($" /* To match against an instance of {name}, write:"); o.WriteLine($" x.Match("); o.WriteLine(String.Join(",\n", variant.Select(@case => - $" {@case.Key}: {@case.Value == null ? "()" : "value"} => throw new NotImplementedYetException(),"))); + $" {@case.Key}: {@case.Value == null ? "()" : "value"} => throw new NotImplementedYetException()"))); o.WriteLine($" )"); o.WriteLine($" */"); @@ -149,6 +149,16 @@ public static class Generator { o.WriteLine(String.Join(",\n", record.Select(@field => $" this.{@field.Key}"))); o.WriteLine($" );"); + foreach (var @field in record) { + var F = @field.Key; + var noAtF = F.StartsWith("@") ? F.Substring(1) : F; + var caseF = Char.ToUpper(noAtF[0]) + noAtF.Substring(1); + var Ty = @field.Value; + o.Write($" public {name} With{caseF}({Ty} {F}) => new {name}("); + o.Write(String.Join(", ", record.Select(@f => $"{f.Key}: {f.Key}"))); + o.WriteLine(");"); + } + o.WriteLine($" }}"); o.WriteLine($"{footer}"); } diff --git a/Utils/Enumerable.cs b/Utils/Enumerable.cs index a46a602..bb9b13c 100644 --- a/Utils/Enumerable.cs +++ b/Utils/Enumerable.cs @@ -152,7 +152,7 @@ public static class Collection { } } - public static Option GetValue(this Dictionary d, K key) { + public static Option GetValue(this ImmutableDictionary d, K key) { V result = default(V); if (d.TryGetValue(key, out result)) { return result.Some(); @@ -161,7 +161,7 @@ public static class Collection { } } - public static V GetOrDefault(this Dictionary d, K key, V defaultValue) { + public static V GetOrDefault(this ImmutableDictionary d, K key, V defaultValue) { V result = default(V); if (d.TryGetValue(key, out result)) { return result; @@ -169,23 +169,4 @@ public static class Collection { return defaultValue; } } - - public class DefaultDictionary : Dictionary { - public readonly TValue defaultValue; - //public readonly Dictionary dictionary; - - public DefaultDictionary(TValue defaultValue, Dictionary dictionary) : base(dictionary) { - this.defaultValue = defaultValue; - //this.dictionary = dictionary; - } - - public new TValue this[TKey key] { - get { - return this.GetOrDefault(key, defaultValue); - } - } - } - - public static DefaultDictionary ToDefaultDictionary(this IEnumerable e, UValue defaultValue, Func key, Func value) - => new DefaultDictionary(defaultValue, e.ToDictionary(key, value)); } \ No newline at end of file diff --git a/Utils/Func.cs b/Utils/Func.cs index 19e942a..1add8ee 100644 --- a/Utils/Func.cs +++ b/Utils/Func.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Mutable = System.Collections.Generic; public static class Func { // supply 1 argument to function of 2 arguments @@ -29,7 +30,7 @@ public static class Func { } public static Func Memoize(this Func f) where A : IEquatable { - var d = new Dictionary(); + var d = new Mutable.Dictionary(); return a => { if (d.TryGetValue(a, out var b)) { return b; diff --git a/Utils/Immutable/DefaultDictionary.cs b/Utils/Immutable/DefaultDictionary.cs new file mode 100644 index 0000000..2eb3824 --- /dev/null +++ b/Utils/Immutable/DefaultDictionary.cs @@ -0,0 +1,30 @@ +//namespace Immutable { + using System; + using System.Collections.Generic; + + public class DefaultDictionary : ImmutableDictionary { + public readonly TValue defaultValue; + + public DefaultDictionary(TValue defaultValue, ImmutableDictionary dictionary) : base(dictionary) { + this.defaultValue = defaultValue; + } + + public DefaultDictionary(DefaultDictionary dictionary, TKey key, TValue value) : base(dictionary, key, value) { + this.defaultValue = dictionary.defaultValue; + } + + public new TValue this[TKey key] { + get { + return this.GetOrDefault(key, defaultValue); + } + } + + public new DefaultDictionary With(TKey key, TValue value) + => new DefaultDictionary(this, key, value); + } + + public static class DefaultDictionaryExtensionMethods { + public static DefaultDictionary ToDefaultDictionary(this IEnumerable e, UValue defaultValue, Func key, Func value) + => new DefaultDictionary(defaultValue, e.ToImmutableDictionary(key, value)); + } +//} \ No newline at end of file diff --git a/Utils/Immutable/Dictionary.cs b/Utils/Immutable/Dictionary.cs new file mode 100644 index 0000000..f8cf701 --- /dev/null +++ b/Utils/Immutable/Dictionary.cs @@ -0,0 +1,71 @@ +//namespace Immutable { + using System; + using System.Linq; + using System.Collections.Generic; + using System.Collections; + using Mutable = System.Collections.Generic; + using Microsoft.FSharp.Collections; + using System.Collections.Immutable; + + // TODO: use Microsoft.FSharp.Collections.FSharpMap + public class ImmutableDictionary : Mutable.IReadOnlyDictionary { + private readonly Mutable.Dictionary d; + private System.Collections.Immutable.ImmutableDictionary i = System.Collections.Immutable.ImmutableDictionary.Empty; + //private readonly FSharpMap x = new FSharpMap(Enumerable.Enpty>()); + + public ImmutableDictionary() { + d = new Mutable.Dictionary(); + } + + public ImmutableDictionary(Mutable.Dictionary d) { + // Clone the mutable dictionary. + this.d = new Mutable.Dictionary(d, d.Comparer); + } + + public ImmutableDictionary(ImmutableDictionary immutableDictionary, TKey key, TValue value) { + // Clone the mutable dictionary contained within that immutable + // dictionary before updating it. + var clone = new Mutable.Dictionary(immutableDictionary.d, immutableDictionary.d.Comparer); + clone.Add(key, value); + this.d = clone; + } + + public ImmutableDictionary(ImmutableDictionary immutableDictionary) { + // No need to clone the mutable dictionary contained within + // that immutable dictionary, since we know it is never mutated. + this.d = immutableDictionary.d; + } + + public TValue this[TKey key] { get => d[key]; } + + public IEnumerable Keys { get => d.Keys; } + public IEnumerable Values { get => d.Values; } + public int Count { get => d.Count; } + public IEqualityComparer Comparer { get => d.Comparer; } + + public bool TryGetValue(TKey key, out TValue value) + => d.TryGetValue(key, out value); + + public bool ContainsKey(TKey key) + => d.ContainsKey(key); + + public ImmutableDictionary With(TKey key, TValue value) + => new ImmutableDictionary(this, key, value); + + IEnumerator> IEnumerable>.GetEnumerator() + => d.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() + => d.GetEnumerator(); + } + + public static class ImmutableDictionaryExtensionMethods { + public static ImmutableDictionary ToImmutableDictionary(this IEnumerable e, Func key, Func value) + => new ImmutableDictionary(e.ToDictionary(key, value)); + } + + // Prevent usage of the mutable dictionary. + public abstract class Dictionary : ImmutableDictionary { + } + +//} diff --git a/main.cs b/main.cs index 7fd9b56..1932a44 100644 --- a/main.cs +++ b/main.cs @@ -81,7 +81,7 @@ public static class MainClass { } } catch (UserErrorException e) { Console.WriteLine(""); - Console.WriteLine(e.Message); + Console.WriteLine($"\x1b[1;33m{e.Message}\x1b[m\n"); Environment.Exit(1); } }