From ca95ab7a248ec2ea7ad62df2fb3040a08718069e Mon Sep 17 00:00:00 2001 From: John Colvin Date: Thu, 14 Sep 2023 15:19:36 -0400 Subject: [PATCH] feat: Add ArithmeticExpressions csproj --- .../ArithmeticExpressions/AdditiveInverse.cs | 37 + .../ArithmeticExpressionExtensions.cs | 45 + .../ArithmeticExpressionGrammar.y | 99 ++ .../ArithmeticExpressionParserImpl.cs | 19 + .../ArithmeticExpressionScanner.cs | 11 + .../ArithmeticExpressionTokens.lex | 70 ++ .../ArithmeticExpressions.csproj | 24 + .../ArithmeticProgram.cs | 21 + .../ArithmeticProgramParser.cs | 16 + .../ArithmeticExpressions/Assignment.cs | 24 + .../ArithmeticExpressions/Difference.cs | 45 + .../EvaluationEnvironment.cs | 208 +++++ .../ArithmeticExpressions/Function.cs | 34 + .../ArithmeticExpressions/GplexBuffers.cs | 720 ++++++++++++++ .../IArithmeticExpression.cs | 19 + .../IArithmeticProgram.cs | 7 + .../ArithmeticExpressions/IntegerConstant.cs | 11 + .../ArithmeticExpressions/Product.cs | 45 + .../ArithmeticExpressions/Quotient.cs | 45 + .../ArithmeticExpressions/RealConstant.cs | 11 + .../ShiftReduceParserCode.cs | 884 ++++++++++++++++++ .../ArithmeticExpressions/Sum.cs | 45 + .../ArithmeticExpressions/Usings.cs | 4 + .../ArithmeticExpressions/Variable.cs | 15 + src/DataStreamSuite/DataStreamSuite.sln | 4 +- .../Extensions/EnumerableExtensions.cs | 3 + 26 files changed, 2465 insertions(+), 1 deletion(-) create mode 100644 src/DataStreamSuite/ArithmeticExpressions/AdditiveInverse.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionExtensions.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionGrammar.y create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionParserImpl.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionScanner.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionTokens.lex create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressions.csproj create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgram.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgramParser.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Assignment.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Difference.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/EvaluationEnvironment.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Function.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/GplexBuffers.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/IArithmeticExpression.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/IArithmeticProgram.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/IntegerConstant.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Product.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Quotient.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/RealConstant.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/ShiftReduceParserCode.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Sum.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Usings.cs create mode 100644 src/DataStreamSuite/ArithmeticExpressions/Variable.cs diff --git a/src/DataStreamSuite/ArithmeticExpressions/AdditiveInverse.cs b/src/DataStreamSuite/ArithmeticExpressions/AdditiveInverse.cs new file mode 100644 index 000000000..724065480 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/AdditiveInverse.cs @@ -0,0 +1,37 @@ +namespace Bts.ArithmeticExpressions; + +using System.Numerics; + +class AdditiveInverse : IArithmeticExpression { + readonly IArithmeticExpression expression; + + public AdditiveInverse(IArithmeticExpression expression) => + this.expression = expression; + + public static AdditiveInverse Create(IArithmeticExpression expression) + where T : INumber => + new(expression); + + public double Evaluate(IDictionary env) => + -evaluateArg(expression, nameof(expression), env); + + static double evaluateArg( + IArithmeticExpression expr, string name, IDictionary env) { + var obj = expr.Evaluate(env); + return ConvertUtils.try_convert(expr.Evaluate(env), out double dbl) ? dbl : + throw new Exception( + $"Invalid AdditiveInverse. {name} is of type {obj?.GetType()} " + + $"(expected {typeof(double)})"); + } +} + +class AdditiveInverse : IArithmeticExpression + where T : INumber { + readonly IArithmeticExpression expression; + + public AdditiveInverse(IArithmeticExpression expression) => + this.expression = expression; + + public T Evaluate(IDictionary env) => + -expression.Evaluate(env); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionExtensions.cs b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionExtensions.cs new file mode 100644 index 000000000..3ef9916bd --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionExtensions.cs @@ -0,0 +1,45 @@ +namespace Bts.ArithmeticExpressions; + +using System.Numerics; + +public static class ArithmeticExpressionExtensions { + public static IArithmeticExpression Add( + this IArithmeticExpression left, IArithmeticExpression right) + where TLeft : + INumber, + IAdditionOperators + where TRight : INumber + where TResult : INumber => + new Sum(left, right); + + public static IArithmeticExpression Subtract( + this IArithmeticExpression left, IArithmeticExpression right) + where TLeft : + INumber, + ISubtractionOperators + where TRight : INumber + where TResult : INumber => + new Difference(left, right); + + public static IArithmeticExpression Multiply( + this IArithmeticExpression left, IArithmeticExpression right) + where TLeft : + INumber, + IMultiplyOperators + where TRight : INumber + where TResult : INumber => + new Product(left, right); + + public static IArithmeticExpression Divide( + this IArithmeticExpression left, IArithmeticExpression right) + where TLeft : + INumber, + IDivisionOperators + where TRight : INumber + where TResult : INumber => + new Quotient(left, right); + + public static IArithmeticExpression Negate(this IArithmeticExpression expression) + where T : INumber => + new AdditiveInverse(expression); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionGrammar.y b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionGrammar.y new file mode 100644 index 000000000..7286154cf --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionGrammar.y @@ -0,0 +1,99 @@ +%namespace Bts.ArithmeticExpressions +%partial +%visibility internal +%tokentype Token +%parsertype ArithmeticExpressionParserImpl + +%union { + public int Integer; + public double Real; + public string Identifier; + public DateTime DateTime; + public ImmutableList Arguments; + public ImmutableList Assignments; + public IArithmeticExpression Argument; + public Assignment Assignment; + public ArithmeticProgram Program; +} + +/* Constants */ +%token INTEGER_CONSTANT REAL_CONSTANT +/* Arithmetic Operators */ +%token ADD, SUBTRACT, MULTIPLY, DIVIDE, EQUALS +/* Syntax */ +%token PARENTHESIS_OPEN, PARENTHESIS_CLOSE, COMMA, IDENTIFIER + +%left ADD SUBTRACT +%left MULTIPLY DIVIDE +%nonassoc EQUALS + +%type Argument +%type Arguments +%type Assignment +%type Assignments +%type Program + +%% + +Program : + Assignments { + $$ = new($1); + } + ; + +Assignments : + Assignment { + $$ = ImmutableList.Empty.Add($1); + } + | Assignments Assignment { + $$ = $1.Add($2); + } + ; + +Assignment : + IDENTIFIER EQUALS Argument { + $$ = new($1.Identifier, $3); + } + ; + +Argument : + IDENTIFIER PARENTHESIS_OPEN Arguments PARENTHESIS_CLOSE { + $$ = new Function($1.Identifier, $3); + } + | INTEGER_CONSTANT { + $$ = new IntegerConstant($1.Integer); + } + | REAL_CONSTANT { + $$ = new RealConstant($1.Real); + } + | IDENTIFIER { + $$ = new Variable($1.Identifier); + } + | SUBTRACT Argument { + $$ = $2.Negate(); + } + | PARENTHESIS_OPEN Argument PARENTHESIS_CLOSE { + $$ = $2; + } + | Argument MULTIPLY Argument { + $$ = $1.Multiply($3); + } + | Argument DIVIDE Argument { + $$ = $1.Divide($3); + } + | Argument ADD Argument { + $$ = $1.Add($3); + } + | Argument SUBTRACT Argument { + $$ = $1.Subtract($3); + } + ; + +Arguments : + Argument { + $$ = ImmutableList.Empty.Add($1); + } + | Arguments COMMA Argument { + $$ = $1.Add($3); + } + ; diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionParserImpl.cs b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionParserImpl.cs new file mode 100644 index 000000000..d6e69ab3e --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionParserImpl.cs @@ -0,0 +1,19 @@ +namespace Bts.ArithmeticExpressions; + +using System.Text; + +partial class ArithmeticExpressionParserImpl { + public ArithmeticExpressionParserImpl() : base(null) { } + + public ValueType Parse(Stream stream) { + Scanner = new ArithmeticExpressionScanner(stream); + Parse(); + return CurrentSemanticValue; + } + + public ValueType Parse(string str) { + var inputBuffer = Encoding.Default.GetBytes(str); + using var stream = new MemoryStream(inputBuffer); + return Parse(stream); + } +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionScanner.cs b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionScanner.cs new file mode 100644 index 000000000..a4de7877d --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionScanner.cs @@ -0,0 +1,11 @@ +namespace Bts.ArithmeticExpressions; + +using System; + +partial class ArithmeticExpressionScanner { + public override void yyerror(string format, params object[] args) { + base.yyerror(format, args); + Console.WriteLine(format, args); + Console.WriteLine(); + } +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionTokens.lex b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionTokens.lex new file mode 100644 index 000000000..8446ae87e --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressionTokens.lex @@ -0,0 +1,70 @@ +%namespace Bts.ArithmeticExpressions +%scannertype ArithmeticExpressionScanner +%visibility internal +%tokentype Token + +%option stack, minimize, parser, verbose, persistbuffer, noembedbuffers + +Letter [a-zA-Z] +Identifier {Letter}({Letter}*[0-9]*_*)* +IntegerConstant -?[0-9]+ +RealConstant -?[0-9]+\.[0-9]+ +ParenthesisOpen \( +ParenthesisClose \) +Add \+ +Subtract \- +Multiply \* +Divide \\ +Equals = +Comma , + +%% + +{IntegerConstant} { + yylval.Integer = int.Parse(yytext); + return (int)Token.INTEGER_CONSTANT; +} + +{RealConstant} { + yylval.Real = double.Parse(yytext); + return (int)Token.REAL_CONSTANT; +} + +{Identifier} { + yylval.Identifier = yytext; + return (int)Token.IDENTIFIER; +} + +{ParenthesisOpen} { + return (int)Token.PARENTHESIS_OPEN; +} + +{ParenthesisClose} { + return (int)Token.PARENTHESIS_CLOSE; +} + +{Add} { + return (int)Token.ADD; +} + +{Subtract} { + return (int)Token.SUBTRACT; +} + +{Multiply} { + return (int)Token.MULTIPLY; +} + +{Divide} { + return (int)Token.DIVIDE; +} + +{Equals} { + return (int)Token.EQUALS; +} + +{Comma} { + return (int)Token.COMMA; +} + +%% diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressions.csproj b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressions.csproj new file mode 100644 index 000000000..0b2f8ed16 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticExpressions.csproj @@ -0,0 +1,24 @@ + + + + net7.0 + enable + enable + + + + + + + + + + + + + + + + + + diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgram.cs b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgram.cs new file mode 100644 index 000000000..7590ebc0e --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgram.cs @@ -0,0 +1,21 @@ +namespace Bts.ArithmeticExpressions; + +using System.Collections.Immutable; + +class ArithmeticProgram : IArithmeticProgram { + readonly ImmutableList? assignments; + + public ArithmeticProgram(Assignment assignment) => + assignments = ImmutableList.Empty.Add(assignment); + + public ArithmeticProgram(ImmutableList assignments) => + this.assignments = assignments; + + IEnumerable IArithmeticProgram.OutputIdentifiers => + assignments.empty_if_null() + .Select(a => a.Identifier ?? throw new Exception("Identifier string is null")) + .Distinct(); + + IDictionary IArithmeticProgram.Evaluate(IDictionary env) => + assignments.empty_if_null().Aggregate(env, (e, a) => a.Evaluate(e)); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgramParser.cs b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgramParser.cs new file mode 100644 index 000000000..3f0e4226f --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ArithmeticProgramParser.cs @@ -0,0 +1,16 @@ +namespace Bts.ArithmeticExpressions; + +using Bts.ExpressionCore; + +public static class ArithmeticProgramParser { + public static IArithmeticProgram Parse(Stream expression) => + new Parser().Parse(expression); + + public static IArithmeticProgram Parse(string expression) => + new Parser().Parse(expression); + + class Parser : IParser { + public ArithmeticProgram Parse(Stream expression) => + new ArithmeticExpressionParserImpl().Parse(expression).Program; + } +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/Assignment.cs b/src/DataStreamSuite/ArithmeticExpressions/Assignment.cs new file mode 100644 index 000000000..951f6954e --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Assignment.cs @@ -0,0 +1,24 @@ +namespace Bts.ArithmeticExpressions; + +public class Assignment { + public Assignment(string? identifier, IArithmeticExpression? value) { + Identifier = identifier ?? throw new ArgumentNullException(nameof(identifier)); + Value = value ?? throw new ArgumentNullException(nameof(identifier)); + } + + public string? Identifier { get; } + public IArithmeticExpression? Value { get; } + + public IDictionary Evaluate(IDictionary env) { + if (Identifier is null) { + throw new InvalidOperationException("Identifier is null"); + } + if (Value is null) { + throw new InvalidOperationException($"Value is null (Identifier '{Identifier}')"); + } + env[Identifier] = Value.Evaluate(env) ?? throw new Exception( + $"{nameof(Assignment)}.{nameof(Value)} (of type '{Value.GetType()}') " + + $"evaluated to null (Identifier '{Identifier}')"); + return env; + } +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/Difference.cs b/src/DataStreamSuite/ArithmeticExpressions/Difference.cs new file mode 100644 index 000000000..50a9eb487 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Difference.cs @@ -0,0 +1,45 @@ +namespace Bts.ArithmeticExpressions; + +using System.Numerics; + +public class Difference : IArithmeticExpression { + readonly IArithmeticExpression lhs; + readonly IArithmeticExpression rhs; + + public Difference(IArithmeticExpression lhs, IArithmeticExpression rhs) { + this.lhs = lhs; + this.rhs = rhs; + } + + public static Difference Create( + IArithmeticExpression left, IArithmeticExpression right) + where T : INumber, ISubtractionOperators => + new(left, right); + + public double Evaluate(IDictionary env) => + evaluateArg(lhs, nameof(lhs), env) - evaluateArg(rhs, nameof(rhs), env); + + static double evaluateArg( + IArithmeticExpression expr, string name, IDictionary env) { + var obj = expr.Evaluate(env); + return ConvertUtils.try_convert(expr.Evaluate(env), out double dbl) ? dbl : + throw new Exception( + $"Invalid Difference. {name} is of type {obj?.GetType()} (expected {typeof(double)})"); + } +} + +public class Difference : IArithmeticExpression + where TLeft : INumber, ISubtractionOperators + where TRight : INumber + where TResult : INumber { + readonly IArithmeticExpression left; + readonly IArithmeticExpression right; + + public Difference(IArithmeticExpression left, IArithmeticExpression right) { + this.left = left; + this.right = right; + } + + public TResult Evaluate(IDictionary env) => + left.Evaluate(env) - right.Evaluate(env); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/EvaluationEnvironment.cs b/src/DataStreamSuite/ArithmeticExpressions/EvaluationEnvironment.cs new file mode 100644 index 000000000..a9a671115 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/EvaluationEnvironment.cs @@ -0,0 +1,208 @@ +namespace Bts.ArithmeticExpressions; + +using System.Collections; +using System.Diagnostics.CodeAnalysis; + +class EvaluationEnvironment : IDictionary, IReadOnlyDictionary { + IDictionary outerEnv; + IDictionary innerEnv = new Dictionary(); + int? count; + + public EvaluationEnvironment(IDictionary initial) => + outerEnv = initial; + + public object? this[string key] { + get { + if (innerEnv.TryGetValue(key, out var rv)) { + return rv; + } + if (outerEnv.TryGetValue(key, out rv)) { + return rv; + } + throw new Exception($"Undefined identifier '{key}'"); + } + set { + if (count.HasValue && !ContainsKey(key)) { + count = count.Value + 1; + innerEnv.Add(key, value); + return; + } + innerEnv[key] = value; + } + } + + public IDictionary Result => + innerEnv; + + public ICollection Keys => + new KeyCollection(outerEnv, innerEnv); + + public ICollection Values => + new ValueCollection(outerEnv, innerEnv); + + public int Count => + count ??= countKeys(outerEnv, innerEnv); + + public bool IsReadOnly => throw new NotImplementedException(); + + public bool ContainsKey(string key) => + innerEnv.ContainsKey(key) || outerEnv.ContainsKey(key); + + public bool TryGetValue(string key, [MaybeNullWhen(false)] out object? value) => + innerEnv.TryGetValue(key, out value) || outerEnv.TryGetValue(key, out value); + + public IEnumerator> GetEnumerator() { + foreach (var kv in innerEnv) { + yield return kv; + } + foreach (var kv in outerEnv.Except()) { + if (!innerEnv.ContainsKey(kv.Key)) { + yield return kv; + } + } + } + + public void Add(string key, object? value) { + if (ContainsKey(key)) { + throw new ArgumentException( + $"An element with the same key ({key}) already exists", nameof(key)); + } + innerEnv.Add(key, value); + } + + public void Add(KeyValuePair item) => + Add(item.Key, item.Value); + + public void Clear() => + throw new NotSupportedException(); + + public bool Contains(KeyValuePair item) => + TryGetValue(item.Key, out var v) && Equals(v, item.Value); + + public void CopyTo(KeyValuePair[] array, int arrayIndex) { + foreach (var kv in innerEnv) { + array[arrayIndex++] = kv; + } + foreach (var kv in outerEnv) { + if (!innerEnv.ContainsKey(kv.Key)) { + array[arrayIndex++] = kv; + } + } + } + + public bool Remove(string key) => + throw new NotSupportedException(); + + public bool Remove(KeyValuePair item) => + throw new NotSupportedException(); + + static int countKeys(IDictionary d1, IDictionary d2) => + d1.Count > d2.Count ? + d1.Count + d2.Keys.WhereNot(d1.ContainsKey).Count() : + d2.Count + d1.Keys.WhereNot(d2.ContainsKey).Count(); + + IEnumerable IReadOnlyDictionary.Keys => Keys; + IEnumerable IReadOnlyDictionary.Values => Values; + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + class KeyCollection : ICollection { + readonly IDictionary outerEnv; + readonly IDictionary innerEnv; + + public KeyCollection( + IDictionary outerEnv, IDictionary innerEnv) { + this.outerEnv = outerEnv; + this.innerEnv = innerEnv; + } + + public int Count => + countKeys(outerEnv, innerEnv); + + public bool IsReadOnly => true; + + public void Add(string item) => + throw new NotSupportedException(); + + public void Clear() => + throw new NotSupportedException(); + + public bool Contains(string item) => + innerEnv.ContainsKey(item) || outerEnv.ContainsKey(item); + + public void CopyTo(string[] array, int arrayIndex) { + foreach (var k in this) { + array[arrayIndex++] = k; + } + } + + public IEnumerator GetEnumerator() { + foreach (var k in innerEnv.Keys) { + yield return k; + } + foreach (var k in outerEnv.Keys) { + if (!innerEnv.ContainsKey(k)) { + yield return k; + } + } + } + + public bool Remove(string item) => + throw new NotSupportedException(); + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + } + + class ValueCollection : ICollection { + readonly IDictionary outerEnv; + readonly IDictionary innerEnv; + + public ValueCollection( + IDictionary outerEnv, IDictionary innerEnv) { + this.outerEnv = outerEnv; + this.innerEnv = innerEnv; + } + + public int Count => + // Not a typo (obv, numValues == numKeys) + countKeys(outerEnv, innerEnv); + + public bool IsReadOnly => true; + + public void Add(object? item) => + throw new NotSupportedException(); + + public void Clear() => + throw new NotSupportedException(); + + public bool Contains(object? item) => + innerEnv.Values.Contains(item) || + outerEnv + .Where(kv => !innerEnv.ContainsKey(kv.Key)) + .Select(kv => kv.Value) + .Contains(item); + + public void CopyTo(object?[] array, int arrayIndex) { + foreach (var k in this) { + array[arrayIndex++] = k; + } + } + + public IEnumerator GetEnumerator() { + foreach (var k in innerEnv.Values) { + yield return k; + } + foreach (var kv in outerEnv) { + if (!innerEnv.ContainsKey(kv.Key)) { + yield return kv.Value; + } + } + } + + public bool Remove(object? item) => + throw new NotSupportedException(); + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + } +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/Function.cs b/src/DataStreamSuite/ArithmeticExpressions/Function.cs new file mode 100644 index 000000000..4e9385bfd --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Function.cs @@ -0,0 +1,34 @@ +namespace Bts.ArithmeticExpressions; + +using Spark.Core; + +using System.Collections.Immutable; +using System.Data; + +public class Function : IArithmeticExpression { + public Function(string? identifier, ImmutableList? arguments) { + Identifier = identifier; + Arguments = arguments; + } + + public string? Identifier { get; } + public ImmutableList? Arguments { get; } + + public object? Evaluate(IDictionary env) { + if (Identifier is null) { + throw new InvalidOperationException("Identifier is null"); + } + if (Arguments is null) { + throw new InvalidOperationException("Arguments is null"); + } + if (Identifier == "ifNull") { + throw new NotImplementedException("'ifNull' function not yet implemented"); + } + var argVals = Arguments.Select(e => e.Evaluate(env)).ToArray(); + var argTypes = Array.ConvertAll(argVals, v => v?.GetType() ?? typeof(object)); + var method = typeof(Math).GetMethod(Identifier, argTypes) ?? + throw new EvaluateException( + $"Failed to find method '{Identifier}({", ".join(argTypes)})' in {typeof(Math)}"); + return method.Invoke(null, argVals); + } +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/GplexBuffers.cs b/src/DataStreamSuite/ArithmeticExpressions/GplexBuffers.cs new file mode 100644 index 000000000..76dd35443 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/GplexBuffers.cs @@ -0,0 +1,720 @@ +// ============================================================== +// +// This code automatically produced from an embedded resource. +// Do not edit this file, or it will become incompatible with +// the specification from which it was generated. +// +// ============================================================== + +using System; +using System.IO; +using System.Text; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.Serialization; +using System.Globalization; + +namespace QUT.GplexBuffers +{ +// Code copied from GPLEX embedded resource + [Serializable] + internal class BufferException : Exception + { + public BufferException() { } + public BufferException(string message) : base(message) { } + public BufferException(string message, Exception innerException) + : base(message, innerException) { } + protected BufferException(SerializationInfo info, StreamingContext context) + : base(info, context) { } + } + + internal abstract class ScanBuff + { + private string fileNm; + + public const int EndOfFile = -1; + public const int UnicodeReplacementChar = 0xFFFD; + + public bool IsFile { get { return (fileNm != null); } } + public string FileName { get { return fileNm; } set { fileNm = value; } } + + public abstract int Pos { get; set; } + public abstract int Read(); + public virtual void Mark() { } + + public abstract string GetString(int begin, int limit); + + public static ScanBuff GetBuffer(string source) + { + return new StringBuffer(source); + } + + public static ScanBuff GetBuffer(IList source) + { + return new LineBuffer(source); + } + +#if (!NOFILES) + public static ScanBuff GetBuffer(Stream source) + { + return new BuildBuffer(source); + } + +#if (!BYTEMODE) + public static ScanBuff GetBuffer(Stream source, int fallbackCodePage) + { + return new BuildBuffer(source, fallbackCodePage); + } +#endif // !BYTEMODE +#endif // !NOFILES + } + + #region Buffer classes + + // ============================================================== + // ===== Definitions for various ScanBuff derived classes ==== + // ============================================================== + // =============== String input ================ + // ============================================================== + + /// + /// This class reads characters from a single string as + /// required, for example, by Visual Studio language services + /// + sealed class StringBuffer : ScanBuff + { + string str; // input buffer + int bPos; // current position in buffer + int sLen; + + public StringBuffer(string source) + { + this.str = source; + this.sLen = source.Length; + this.FileName = null; + } + + public override int Read() + { + if (bPos < sLen) return str[bPos++]; + else if (bPos == sLen) { bPos++; return '\n'; } // one strike, see new line + else { bPos++; return EndOfFile; } // two strikes and you're out! + } + + public override string GetString(int begin, int limit) + { + // "limit" can be greater than sLen with the BABEL + // option set. Read returns a "virtual" EOL if + // an attempt is made to read past the end of the + // string buffer. Without the guard any attempt + // to fetch yytext for a token that includes the + // EOL will throw an index exception. + if (limit > sLen) limit = sLen; + if (limit <= begin) return ""; + else return str.Substring(begin, limit - begin); + } + + public override int Pos + { + get { return bPos; } + set { bPos = value; } + } + + public override string ToString() { return "StringBuffer"; } + } + + // ============================================================== + // The LineBuff class contributed by Nigel Horspool, + // nigelh@cs.uvic.cs + // ============================================================== + + sealed class LineBuffer : ScanBuff + { + IList line; // list of source lines from a file + int numLines; // number of strings in line list + string curLine; // current line in that list + int cLine; // index of current line in the list + int curLen; // length of current line + int curLineStart; // position of line start in whole file + int curLineEnd; // position of line end in whole file + int maxPos; // max position ever visited in whole file + int cPos; // ordinal number of code in source + + // Constructed from a list of strings, one per source line. + // The lines have had trailing '\n' characters removed. + public LineBuffer(IList lineList) + { + line = lineList; + numLines = line.Count; + cPos = curLineStart = 0; + curLine = (numLines > 0 ? line[0] : ""); + maxPos = curLineEnd = curLen = curLine.Length; + cLine = 1; + FileName = null; + } + + public override int Read() + { + if (cPos < curLineEnd) + return curLine[cPos++ - curLineStart]; + if (cPos++ == curLineEnd) + return '\n'; + if (cLine >= numLines) + return EndOfFile; + curLine = line[cLine]; + curLen = curLine.Length; + curLineStart = curLineEnd + 1; + curLineEnd = curLineStart + curLen; + if (curLineEnd > maxPos) + maxPos = curLineEnd; + cLine++; + return curLen > 0 ? curLine[0] : '\n'; + } + + // To speed up searches for the line containing a position + private int cachedPosition; + private int cachedIxdex; + private int cachedLineStart; + + // Given a position pos within the entire source, the results are + // ix -- the index of the containing line + // lstart -- the position of the first character on that line + private void findIndex(int pos, out int ix, out int lstart) + { + if (pos >= cachedPosition) + { + ix = cachedIxdex; lstart = cachedLineStart; + } + else + { + ix = lstart = 0; + } + while (ix < numLines) + { + int len = line[ix].Length + 1; + if (pos < lstart + len) break; + lstart += len; + ix++; + } + cachedPosition = pos; + cachedIxdex = ix; + cachedLineStart = lstart; + } + + public override string GetString(int begin, int limit) + { + if (begin >= maxPos || limit <= begin) return ""; + int endIx, begIx, endLineStart, begLineStart; + findIndex(begin, out begIx, out begLineStart); + int begCol = begin - begLineStart; + findIndex(limit, out endIx, out endLineStart); + int endCol = limit - endLineStart; + string s = line[begIx]; + if (begIx == endIx) + { + // the usual case, substring all on one line + return (endCol <= s.Length) ? + s.Substring(begCol, endCol - begCol) + : s.Substring(begCol) + "\n"; + } + // the string spans multiple lines, yuk! + StringBuilder sb = new StringBuilder(); + if (begCol < s.Length) + sb.Append(s.Substring(begCol)); + for (; ; ) + { + sb.Append("\n"); + s = line[++begIx]; + if (begIx >= endIx) break; + sb.Append(s); + } + if (endCol <= s.Length) + { + sb.Append(s.Substring(0, endCol)); + } + else + { + sb.Append(s); + sb.Append("\n"); + } + return sb.ToString(); + } + + public override int Pos + { + get { return cPos; } + set + { + cPos = value; + findIndex(cPos, out cLine, out curLineStart); + // cLine should be the *next* line after curLine. + curLine = (cLine < numLines ? line[cLine++] : ""); + curLineEnd = curLineStart + curLine.Length; + } + } + + public override string ToString() { return "LineBuffer"; } + } + +#if (!NOFILES) + // ============================================================== + // ===== class BuildBuff : for unicode text files ======== + // ============================================================== + + class BuildBuffer : ScanBuff + { + // Double buffer for char stream. + class BufferElement + { + StringBuilder bldr = new StringBuilder(); + StringBuilder next = new StringBuilder(); + int minIx; + int maxIx; + int brkIx; + bool appendToNext; + + internal BufferElement() { } + + internal int MaxIndex { get { return maxIx; } } + // internal int MinIndex { get { return minIx; } } + + internal char this[int index] + { + get + { + if (index < minIx || index >= maxIx) + throw new BufferException("Index was outside data buffer"); + else if (index < brkIx) + return bldr[index - minIx]; + else + return next[index - brkIx]; + } + } + + internal void Append(char[] block, int count) + { + maxIx += count; + if (appendToNext) + this.next.Append(block, 0, count); + else + { + this.bldr.Append(block, 0, count); + brkIx = maxIx; + appendToNext = true; + } + } + + internal string GetString(int start, int limit) + { + if (limit <= start) + return ""; + if (start >= minIx && limit <= maxIx) + if (limit < brkIx) // String entirely in bldr builder + return bldr.ToString(start - minIx, limit - start); + else if (start >= brkIx) // String entirely in next builder + return next.ToString(start - brkIx, limit - start); + else // Must do a string-concatenation + return + bldr.ToString(start - minIx, brkIx - start) + + next.ToString(0, limit - brkIx); + else + throw new BufferException("String was outside data buffer"); + } + + internal void Mark(int limit) + { + if (limit > brkIx + 16) // Rotate blocks + { + StringBuilder temp = bldr; + bldr = next; + next = temp; + next.Length = 0; + minIx = brkIx; + brkIx = maxIx; + } + } + } + + BufferElement data = new BufferElement(); + + int bPos; // Postion index in the StringBuilder + BlockReader NextBlk; // Delegate that serves char-arrays; + + private string EncodingName + { + get + { + StreamReader rdr = NextBlk.Target as StreamReader; + return (rdr == null ? "raw-bytes" : rdr.CurrentEncoding.BodyName); + } + } + + public BuildBuffer(Stream stream) + { + FileStream fStrm = (stream as FileStream); + if (fStrm != null) FileName = fStrm.Name; + NextBlk = BlockReaderFactory.Raw(stream); + } + +#if (!BYTEMODE) + public BuildBuffer(Stream stream, int fallbackCodePage) + { + FileStream fStrm = (stream as FileStream); + if (fStrm != null) FileName = fStrm.Name; + NextBlk = BlockReaderFactory.Get(stream, fallbackCodePage); + } +#endif + + /// + /// Marks a conservative lower bound for the buffer, + /// allowing space to be reclaimed. If an application + /// needs to call GetString at arbitrary past locations + /// in the input stream, Mark() is not called. + /// + public override void Mark() { data.Mark(bPos - 2); } + + public override int Pos + { + get { return bPos; } + set { bPos = value; } + } + + + /// + /// Read returns the ordinal number of the next char, or + /// EOF (-1) for an end of stream. Note that the next + /// code point may require *two* calls of Read(). + /// + /// + public override int Read() + { + // + // Characters at positions + // [data.offset, data.offset + data.bldr.Length) + // are available in data.bldr. + // + if (bPos < data.MaxIndex) + { + // ch0 cannot be EOF + return (int)data[bPos++]; + } + else // Read from underlying stream + { + // Experimental code, blocks of page size + char[] chrs = new char[4096]; + int count = NextBlk(chrs, 0, 4096); + if (count == 0) + return EndOfFile; + else + { + data.Append(chrs, count); + return (int)data[bPos++]; + } + } + } + + public override string GetString(int begin, int limit) + { + return data.GetString(begin, limit); + } + + public override string ToString() + { + return "StringBuilder buffer, encoding: " + this.EncodingName; + } + } + + // =============== End ScanBuff-derived classes ================== + + internal delegate int BlockReader(char[] block, int index, int number); + + // A delegate factory, serving up a delegate that + // reads a block of characters from the underlying + // encoded stream, via a StreamReader object. + // + internal static class BlockReaderFactory + { + public static BlockReader Raw(Stream stream) + { + return delegate(char[] block, int index, int number) + { + byte[] b = new byte[number]; + int count = stream.Read(b, 0, number); + int i = 0; + int j = index; + for (; i < count; i++, j++) + block[j] = (char)b[i]; + return count; + }; + } + +#if (!BYTEMODE) + public static BlockReader Get(Stream stream, int fallbackCodePage) + { + Encoding encoding; + int preamble = Preamble(stream); + + if (preamble != 0) // There is a valid BOM here! + encoding = Encoding.GetEncoding(preamble); + else if (fallbackCodePage == -1) // Fallback is "raw" bytes + return Raw(stream); + else if (fallbackCodePage != -2) // Anything but "guess" + encoding = Encoding.GetEncoding(fallbackCodePage); + else // This is the "guess" option + { + int guess = new Guesser(stream).GuessCodePage(); + stream.Seek(0, SeekOrigin.Begin); + if (guess == -1) // ==> this is a 7-bit file + encoding = Encoding.ASCII; + else if (guess == 65001) + encoding = Encoding.UTF8; + else // ==> use the machine default + encoding = Encoding.Default; + } + StreamReader reader = new StreamReader(stream, encoding); + return reader.Read; + } + + static int Preamble(Stream stream) + { + int b0 = stream.ReadByte(); + int b1 = stream.ReadByte(); + + if (b0 == 0xfe && b1 == 0xff) + return 1201; // UTF16BE + if (b0 == 0xff && b1 == 0xfe) + return 1200; // UTF16LE + + int b2 = stream.ReadByte(); + if (b0 == 0xef && b1 == 0xbb && b2 == 0xbf) + return 65001; // UTF8 + // + // There is no unicode preamble, so we + // return denoter for the machine default. + // + stream.Seek(0, SeekOrigin.Begin); + return 0; + } +#endif // !BYTEMODE + } +#endif // !NOFILES + #endregion Buffer classes + + // ============================================================== + // ============ class CodePageHandling ============= + // ============================================================== +#if (!NOFILES) + public static class CodePageHandling + { + public static int GetCodePage(string option) + { + string command = option.ToUpperInvariant(); + if (command.StartsWith("CodePage:", StringComparison.OrdinalIgnoreCase)) + command = command.Substring(9); + try + { + if (command.Equals("RAW")) + return -1; + else if (command.Equals("GUESS")) + return -2; + else if (command.Equals("DEFAULT")) + return 0; + else if (char.IsDigit(command[0])) + return int.Parse(command, CultureInfo.InvariantCulture); + else + { + Encoding enc = Encoding.GetEncoding(command); + return enc.CodePage; + } + } + catch (FormatException) + { + Console.Error.WriteLine( + "Invalid format \"{0}\", using machine default", option); + } + catch (ArgumentException) + { + Console.Error.WriteLine( + "Unknown code page \"{0}\", using machine default", option); + } + return 0; + } + } +#region guesser +#if (!BYTEMODE) + // ============================================================== + // ============ Encoding Guesser ============= + // ============================================================== + + /// + /// This class provides a simple finite state automaton that + /// scans the file looking for (1) valid UTF-8 byte patterns, + /// (2) bytes >= 0x80 which are not part of a UTF-8 sequence. + /// The method then guesses whether it is UTF-8 or maybe some + /// local machine default encoding. This works well for the + /// various Latin encodings. + /// + internal class Guesser + { + ScanBuff buffer; + + public int GuessCodePage() { return Scan(); } + + const int maxAccept = 10; + const int initial = 0; + const int eofNum = 0; + const int goStart = -1; + const int INITIAL = 0; + const int EndToken = 0; + + #region user code + /* + * Reads the bytes of a file to determine if it is + * UTF-8 or a single-byte code page file. + */ + public long utfX; + public long uppr; + #endregion user code + + int state; + int currentStart = startState[0]; + int code; + + #region ScannerTables + static int[] startState = new int[] { 11, 0 }; + + #region CharacterMap + static sbyte[] map = new sbyte[256] { +/* '\0' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '\x10' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '\x20' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '0' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '@' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* 'P' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '`' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* 'p' */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* '\x80' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\x90' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\xA0' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\xB0' */ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, +/* '\xC0' */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* '\xD0' */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +/* '\xE0' */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, +/* '\xF0' */ 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5 }; + #endregion + + static sbyte[][] nextState = new sbyte[][] { + new sbyte[] {0, 0, 0, 0, 0, 0}, + new sbyte[] {-1, -1, 10, -1, -1, -1}, + new sbyte[] {-1, -1, -1, -1, -1, -1}, + new sbyte[] {-1, -1, 8, -1, -1, -1}, + new sbyte[] {-1, -1, 5, -1, -1, -1}, + new sbyte[] {-1, -1, 6, -1, -1, -1}, + new sbyte[] {-1, -1, 7, -1, -1, -1}, + null, + new sbyte[] {-1, -1, 9, -1, -1, -1}, + null, + null, + new sbyte[] {-1, 1, 2, 3, 4, 2} + }; + + + [SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline")] + // Reason for suppression: cannot have self-reference in array initializer. + static Guesser() + { + nextState[7] = nextState[2]; + nextState[9] = nextState[2]; + nextState[10] = nextState[2]; + } + + int NextState() + { + if (code == ScanBuff.EndOfFile) + return eofNum; + else + return nextState[state][map[code]]; + } + #endregion + + public Guesser(System.IO.Stream file) { SetSource(file); } + + public void SetSource(System.IO.Stream source) + { + this.buffer = new BuildBuffer(source); + code = buffer.Read(); + } + + int Scan() + { + for (; ; ) + { + int next; + state = currentStart; + while ((next = NextState()) == goStart) + code = buffer.Read(); + + state = next; + code = buffer.Read(); + + while ((next = NextState()) > eofNum) + { + state = next; + code = buffer.Read(); + } + if (state <= maxAccept) + { + #region ActionSwitch +#pragma warning disable 162 + switch (state) + { + case eofNum: + switch (currentStart) + { + case 11: + if (utfX == 0 && uppr == 0) return -1; /* raw ascii */ + else if (uppr * 10 > utfX) return 0; /* default code page */ + else return 65001; /* UTF-8 encoding */ + break; + } + return EndToken; + case 1: // Recognized '{Upper128}', Shortest string "\xC0" + case 2: // Recognized '{Upper128}', Shortest string "\x80" + case 3: // Recognized '{Upper128}', Shortest string "\xE0" + case 4: // Recognized '{Upper128}', Shortest string "\xF0" + uppr++; + break; + case 5: // Recognized '{Utf8pfx4}{Utf8cont}', Shortest string "\xF0\x80" + uppr += 2; + break; + case 6: // Recognized '{Utf8pfx4}{Utf8cont}{2}', Shortest string "\xF0\x80\x80" + uppr += 3; + break; + case 7: // Recognized '{Utf8pfx4}{Utf8cont}{3}', Shortest string "\xF0\x80\x80\x80" + utfX += 3; + break; + case 8: // Recognized '{Utf8pfx3}{Utf8cont}', Shortest string "\xE0\x80" + uppr += 2; + break; + case 9: // Recognized '{Utf8pfx3}{Utf8cont}{2}', Shortest string "\xE0\x80\x80" + utfX += 2; + break; + case 10: // Recognized '{Utf8pfx2}{Utf8cont}', Shortest string "\xC0\x80" + utfX++; + break; + default: + break; + } +#pragma warning restore 162 + #endregion + } + } + } + } // end class Guesser + +#endif // !BYTEMODE +#endregion +#endif // !NOFILES + +// End of code copied from embedded resource +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/IArithmeticExpression.cs b/src/DataStreamSuite/ArithmeticExpressions/IArithmeticExpression.cs new file mode 100644 index 000000000..f44abe00f --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/IArithmeticExpression.cs @@ -0,0 +1,19 @@ +namespace Bts.ArithmeticExpressions; + +using System.Numerics; + +public interface IArithmeticExpression { + IArithmeticExpression Add(IArithmeticExpression factor) => new Sum(this, factor); + IArithmeticExpression Divide(IArithmeticExpression other) => new Quotient(this, other); + IArithmeticExpression Multiply(IArithmeticExpression other) => new Product(this, other); + IArithmeticExpression Subtract(IArithmeticExpression other) => new Difference(this, other); + IArithmeticExpression Negate() => new AdditiveInverse(this); + object? Evaluate(IDictionary env); +} + +public interface IArithmeticExpression : IArithmeticExpression where T : INumber { + new T Evaluate(IDictionary env); + + object? IArithmeticExpression.Evaluate(IDictionary env) => + Evaluate(env); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/IArithmeticProgram.cs b/src/DataStreamSuite/ArithmeticExpressions/IArithmeticProgram.cs new file mode 100644 index 000000000..2f1d76499 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/IArithmeticProgram.cs @@ -0,0 +1,7 @@ +namespace Bts.ArithmeticExpressions; + +public interface IArithmeticProgram { + IEnumerable OutputIdentifiers { get; } + + IDictionary Evaluate(IDictionary env); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/IntegerConstant.cs b/src/DataStreamSuite/ArithmeticExpressions/IntegerConstant.cs new file mode 100644 index 000000000..a2c36c1ed --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/IntegerConstant.cs @@ -0,0 +1,11 @@ +namespace Bts.ArithmeticExpressions; + +class IntegerConstant : IArithmeticExpression { + readonly int value; + + public IntegerConstant(int value) => + this.value = value; + + public int Evaluate(IDictionary env) => + value; +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/Product.cs b/src/DataStreamSuite/ArithmeticExpressions/Product.cs new file mode 100644 index 000000000..da9eb6e7e --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Product.cs @@ -0,0 +1,45 @@ +namespace Bts.ArithmeticExpressions; + +using System.Numerics; + +class Product : IArithmeticExpression { + readonly IArithmeticExpression left; + readonly IArithmeticExpression right; + + public Product(IArithmeticExpression left, IArithmeticExpression right) { + this.left = left; + this.right = right; + } + + public static Product Create( + IArithmeticExpression left, IArithmeticExpression right) + where T : INumber, IMultiplyOperators => + new(left, right); + + public double Evaluate(IDictionary env) => + evaluateArg(left, nameof(left), env) * evaluateArg(right, nameof(right), env); + + static double evaluateArg( + IArithmeticExpression expr, string name, IDictionary env) { + var obj = expr.Evaluate(env); + return ConvertUtils.try_convert(expr.Evaluate(env), out double dbl) ? dbl : + throw new Exception( + $"Invalid Product. {name} is of type {obj?.GetType()} (expected {typeof(double)})"); + } +} + +class Product : IArithmeticExpression + where TLeft : INumber, IMultiplyOperators + where TRight : INumber + where TResult : INumber { + readonly IArithmeticExpression left; + readonly IArithmeticExpression right; + + public Product(IArithmeticExpression left, IArithmeticExpression right) { + this.left = left; + this.right = right; + } + + public TResult Evaluate(IDictionary env) => + left.Evaluate(env) * right.Evaluate(env); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/Quotient.cs b/src/DataStreamSuite/ArithmeticExpressions/Quotient.cs new file mode 100644 index 000000000..7b6a2df40 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Quotient.cs @@ -0,0 +1,45 @@ +namespace Bts.ArithmeticExpressions; + +using System.Numerics; + +class Quotient : IArithmeticExpression { + readonly IArithmeticExpression left; + readonly IArithmeticExpression right; + + public Quotient(IArithmeticExpression left, IArithmeticExpression right) { + this.left = left; + this.right = right; + } + + public static Quotient Create( + IArithmeticExpression left, IArithmeticExpression right) + where T : INumber, IDivisionOperators => + new(left, right); + + public double Evaluate(IDictionary env) => + evaluateArg(left, nameof(left), env) / evaluateArg(right, nameof(right), env); + + static double evaluateArg( + IArithmeticExpression expr, string name, IDictionary env) { + var obj = expr.Evaluate(env); + return ConvertUtils.try_convert(expr.Evaluate(env), out double dbl) ? dbl : + throw new Exception( + $"Invalid Quotient. {name} is of type {obj?.GetType()} (expected {typeof(double)})"); + } +} + +class Quotient : IArithmeticExpression + where TLeft : INumber, IDivisionOperators + where TRight : INumber + where TResult : INumber { + readonly IArithmeticExpression left; + readonly IArithmeticExpression right; + + public Quotient(IArithmeticExpression left, IArithmeticExpression right) { + this.left = left; + this.right = right; + } + + public TResult Evaluate(IDictionary env) => + left.Evaluate(env) / right.Evaluate(env); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/RealConstant.cs b/src/DataStreamSuite/ArithmeticExpressions/RealConstant.cs new file mode 100644 index 000000000..a2c3f91c4 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/RealConstant.cs @@ -0,0 +1,11 @@ +namespace Bts.ArithmeticExpressions; + +class RealConstant : IArithmeticExpression { + readonly double value; + + public RealConstant(double value) => + this.value = value; + + public double Evaluate(IDictionary env) => + value; +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/ShiftReduceParserCode.cs b/src/DataStreamSuite/ArithmeticExpressions/ShiftReduceParserCode.cs new file mode 100644 index 000000000..a255acb0d --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/ShiftReduceParserCode.cs @@ -0,0 +1,884 @@ +// ============================================================== +// +// This code automatically produced from an embedded resource. +// Do not edit this file, or it will become incompatible with +// the specification from which it was generated. +// +// ============================================================== + +// Gardens Point Parser Generator +// Copyright (c) Wayne Kelly, QUT 2005-2010 +// (see accompanying GPPGcopyright.rtf) + +using System; +using System.Text; +using System.Globalization; +using System.Collections.Generic; +using System.Runtime.Serialization; +using System.Diagnostics.CodeAnalysis; + +namespace QUT.Gppg { + /// + /// Abstract class for GPPG shift-reduce parsers. + /// Parsers generated by GPPG derive from this base + /// class, overriding the abstract Initialize() and + /// DoAction() methods. + /// + /// Semantic value type + /// Location type +#if EXPORT_GPPG + public abstract class ShiftReduceParser +#else + internal abstract class ShiftReduceParser +#endif + where TSpan : IMerge, new() { + private AbstractScanner scanner; + /// + /// The abstract scanner for this parser. + /// + protected AbstractScanner Scanner { + get { return scanner; } + set { scanner = value; } + } + + /// + /// Constructor for base class + /// + /// Scanner instance for this parser + protected ShiftReduceParser( AbstractScanner scanner ) { + this.scanner = scanner; + } + + // ============================================================== + // TECHNICAL EXPLANATION. + // Why the next two fields are not exposed via properties. + // ============================================================== + // These fields are of the generic parameter types, and are + // frequently instantiated as struct types in derived classes. + // Semantic actions are defined in the derived classes and refer + // to instance fields of these structs. In such cases the code + // "get_CurrentSemanticValue().myField = blah;" will fail since + // the getter pushes the value of the field, not the reference. + // So, in the presence of properties, gppg would need to encode + // such field accesses as ... + // "tmp = get_CurrentSemanticValue(); // Fetch value + // tmp.myField = blah; // update + // set_CurrentSemanticValue(tmp); " // Write update back. + // There is no issue if TValue is restricted to be a ref type. + // The same explanation applies to scanner.yylval. + // ============================================================== + /// + /// The current value of the "$$" symbolic variable in the parser + /// + [SuppressMessage( "Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields" )] + protected TValue CurrentSemanticValue; + + /// + /// The current value of the "@$" symbolic variable in the parser + /// + [SuppressMessage( "Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields" )] + protected TSpan CurrentLocationSpan; + protected int NextToken; + + private TSpan LastSpan; + private State FsaState; + private bool recovering; + private int tokensSinceLastError; + + private PushdownPrefixState StateStack = new PushdownPrefixState(); + private PushdownPrefixState valueStack = new PushdownPrefixState(); + private PushdownPrefixState locationStack = new PushdownPrefixState(); + + /// + /// The stack of semantic value (YYSTYPE) values. + /// + protected PushdownPrefixState ValueStack { get { return valueStack; } } + + /// + /// The stack of location value (YYLTYPE) varlues. + /// + protected PushdownPrefixState LocationStack { get { return locationStack; } } + + private int errorToken; + private int endOfFileToken; + private string[] nonTerminals; + private State[] states; + private Rule[] rules; + + /// + /// Initialization method to allow derived classes + /// to insert the rule list into this base class. + /// + /// The array of Rule objects + protected void InitRules( Rule[] rules ) { this.rules = rules; } + + /// + /// Initialization method to allow derived classes to + /// insert the states table into this base class. + /// + /// The pre-initialized states table + protected void InitStates( State[] states ) { this.states = states; } + + /// + /// OBSOLETE FOR VERSION 1.4.0 + /// + /// + protected void InitStateTable( int size ) { states = new State[size]; } + + /// + /// Initialization method to allow derived classes + /// to insert the special value for the error and EOF tokens. + /// + /// The error state ordinal + /// The EOF stat ordinal + protected void InitSpecialTokens( int err, int end ) { + errorToken = err; + endOfFileToken = end; + } + + /// + /// Initialization method to allow derived classes to + /// insert the non-terminal symbol names into this base class. + /// + /// Non-terminal symbol names + protected void InitNonTerminals( string[] names ) { nonTerminals = names; } + + #region YYAbort, YYAccept etcetera. + [Serializable] + [SuppressMessage( "Microsoft.Design", "CA1064:ExceptionsShouldBePublic" )] + // Reason for FxCop message suppression - + // This exception cannot escape from the local context + private class AcceptException : Exception { + internal AcceptException() { } + protected AcceptException( SerializationInfo i, StreamingContext c ) : base( i, c ) { } + } + [Serializable] + [SuppressMessage( "Microsoft.Design", "CA1064:ExceptionsShouldBePublic" )] + // Reason for FxCop message suppression - + // This exception cannot escape from the local context + private class AbortException : Exception { + internal AbortException() { } + protected AbortException( SerializationInfo i, StreamingContext c ) : base( i, c ) { } + } + [Serializable] + [SuppressMessage( "Microsoft.Design", "CA1064:ExceptionsShouldBePublic" )] + // Reason for FxCop message suppression - + // This exception cannot escape from the local context + private class ErrorException : Exception { + internal ErrorException() { } + protected ErrorException( SerializationInfo i, StreamingContext c ) : base( i, c ) { } + } + + // The following methods are only called from within + // a semantic action. The thrown exceptions can never + // propagate outside the ShiftReduceParser class in + // which they are nested. + + /// + /// Force parser to terminate, returning "true" + /// + protected static void YYAccept() { throw new AcceptException(); } + + /// + /// Force parser to terminate, returning "false" + /// + protected static void YYAbort() { throw new AbortException(); } + + /// + /// Force parser to terminate, returning + /// "false" if error recovery fails. + /// + protected static void YYError() { throw new ErrorException(); } + + /// + /// Check if parser in error recovery state. + /// + protected bool YYRecovering { get { return recovering; } } + #endregion + + /// + /// Abstract base method. ShiftReduceParser calls this + /// to initialize the base class data structures. Concrete + /// parser classes must override this method. + /// + protected abstract void Initialize(); + + /// + /// Main entry point of the Shift-Reduce Parser. + /// + /// True if parse succeeds, else false for + /// unrecoverable errors + public bool Parse() { + Initialize(); // allow derived classes to instantiate rules, states and nonTerminals + + NextToken = 0; + FsaState = states[0]; + + StateStack.Push( FsaState ); + valueStack.Push( CurrentSemanticValue ); + LocationStack.Push( CurrentLocationSpan ); + + while (true) { +#if TRACE_ACTIONS + Console.Error.WriteLine("Entering state {0} ", FsaState.number); + DisplayStack(); +#endif + int action = FsaState.defaultAction; + + if (FsaState.ParserTable != null) { + if (NextToken == 0) { + // We save the last token span, so that the location span + // of production right hand sides that begin or end with a + // nullable production will be correct. + LastSpan = scanner.yylloc; + NextToken = scanner.yylex(); +#if TRACE_ACTIONS + Console.Error.WriteLine( "Reading: Next token is {0}", TerminalToString( NextToken ) ); +#endif + } +#if TRACE_ACTIONS + else + Console.Error.WriteLine( "Next token is still {0}", TerminalToString( NextToken ) ); +#endif + if (FsaState.ParserTable.ContainsKey( NextToken )) + action = FsaState.ParserTable[NextToken]; + } + + if (action > 0) // shift + { + Shift( action ); + } + else if (action < 0) // reduce + { + try { + Reduce( -action ); + if (action == -1) // accept + return true; + } + catch (AbortException) { + return false; + } + catch (AcceptException) { + return true; + } + catch (ErrorException) { + if (!ErrorRecovery()) + return false; + else + throw; // Rethrow x, preserving information. + } + } + else if (action == 0 && !ErrorRecovery()) // error + return false; + } + } + + private void Shift( int stateIndex ) { +#if TRACE_ACTIONS + Console.Error.Write("Shifting token {0}, ", TerminalToString(NextToken)); +#endif + FsaState = states[stateIndex]; + + valueStack.Push( scanner.yylval ); + StateStack.Push( FsaState ); + LocationStack.Push( scanner.yylloc ); + + if (recovering) { + if (NextToken != errorToken) + tokensSinceLastError++; + + if (tokensSinceLastError > 5) + recovering = false; + } + + if (NextToken != endOfFileToken) + NextToken = 0; + } + + private void Reduce( int ruleNumber ) { +#if TRACE_ACTIONS + DisplayRule(ruleNumber); +#endif + Rule rule = rules[ruleNumber]; + int rhLen = rule.RightHandSide.Length; + // + // Default actions for unit productions. + // + if (rhLen == 1) { + CurrentSemanticValue = valueStack.TopElement(); // Default action: $$ = $1; + CurrentLocationSpan = LocationStack.TopElement(); // Default action "@$ = @1; + } + else if (rhLen == 0) { + // Create a new blank value. + // Explicit semantic action may mutate this value + CurrentSemanticValue = default( TValue ); + // The location span for an empty production will start with the + // beginning of the next lexeme, and end with the finish of the + // previous lexeme. This gives the correct behaviour when this + // nonsense value is used in later Merge operations. + CurrentLocationSpan = (scanner.yylloc != null && LastSpan != null ? + scanner.yylloc.Merge( LastSpan ) : + default( TSpan )); + } + else { + // Default action: $$ = $1; + CurrentSemanticValue = valueStack[LocationStack.Depth - rhLen]; + // Default action "@$ = @1.Merge(@N)" for location info. + TSpan at1 = LocationStack[LocationStack.Depth - rhLen]; + TSpan atN = LocationStack[LocationStack.Depth - 1]; + CurrentLocationSpan = + ((at1 != null && atN != null) ? at1.Merge( atN ) : default( TSpan )); + } + + DoAction( ruleNumber ); + + for (int i = 0; i < rule.RightHandSide.Length; i++) { + StateStack.Pop(); + valueStack.Pop(); + LocationStack.Pop(); + } + FsaState = StateStack.TopElement(); + + if (FsaState.Goto.ContainsKey( rule.LeftHandSide )) + FsaState = states[FsaState.Goto[rule.LeftHandSide]]; + + StateStack.Push( FsaState ); + valueStack.Push( CurrentSemanticValue ); + LocationStack.Push( CurrentLocationSpan ); + } + + /// + /// Execute the selected action from array. + /// Must be overriden in derived classes. + /// + /// Index of the action to perform + protected abstract void DoAction( int actionNumber ); + + private bool ErrorRecovery() { + bool discard; + + if (!recovering) // if not recovering from previous error + ReportError(); + + if (!FindErrorRecoveryState()) + return false; + // + // The interim fix for the "looping in error recovery" + // artifact involved moving the setting of the recovering + // bool until after invalid tokens have been discarded. + // + ShiftErrorToken(); + discard = DiscardInvalidTokens(); + recovering = true; + tokensSinceLastError = 0; + return discard; + } + + private void ReportError() { + StringBuilder errorMsg = new StringBuilder(); + errorMsg.AppendFormat( "Syntax error, unexpected {0}", TerminalToString( NextToken ) ); + + if (FsaState.ParserTable.Count < 7) { + bool first = true; + foreach (int terminal in FsaState.ParserTable.Keys) { + if (first) + errorMsg.Append( ", expecting " ); + else + errorMsg.Append( ", or " ); + + errorMsg.Append( TerminalToString( terminal ) ); + first = false; + } + } + scanner.yyerror( errorMsg.ToString() ); + } + + private void ShiftErrorToken() { + int old_next = NextToken; + NextToken = errorToken; + + Shift( FsaState.ParserTable[NextToken] ); + +#if TRACE_ACTIONS + Console.Error.WriteLine("Entering state {0} ", FsaState.number); +#endif + NextToken = old_next; + } + + private bool FindErrorRecoveryState() { + while (true) // pop states until one found that accepts error token + { + if (FsaState.ParserTable != null && + FsaState.ParserTable.ContainsKey( errorToken ) && + FsaState.ParserTable[errorToken] > 0) // shift + return true; + +#if TRACE_ACTIONS + Console.Error.WriteLine("Error: popping state {0}", StateStack.TopElement().number); +#endif + StateStack.Pop(); + valueStack.Pop(); + LocationStack.Pop(); + +#if TRACE_ACTIONS + DisplayStack(); +#endif + if (StateStack.IsEmpty()) { +#if TRACE_ACTIONS + Console.Error.WriteLine("Aborting: didn't find a state that accepts error token"); +#endif + return false; + } + else + FsaState = StateStack.TopElement(); + } + } + + private bool DiscardInvalidTokens() { + + int action = FsaState.defaultAction; + + if (FsaState.ParserTable != null) { + // Discard tokens until find one that works ... + while (true) { + if (NextToken == 0) { +#if TRACE_ACTIONS + Console.Error.Write("Reading a token: "); +#endif + NextToken = scanner.yylex(); + } +#if TRACE_ACTIONS + Console.Error.WriteLine("Next token is {0}", TerminalToString(NextToken)); +#endif + if (NextToken == endOfFileToken) + return false; + + if (FsaState.ParserTable.ContainsKey( NextToken )) + action = FsaState.ParserTable[NextToken]; + + if (action != 0) + return true; + else { +#if TRACE_ACTIONS + Console.Error.WriteLine("Error: Discarding {0}", TerminalToString(NextToken)); +#endif + NextToken = 0; + } + } + } + else if (recovering && tokensSinceLastError == 0) { + // + // Boolean recovering is not set until after the first + // error token has been shifted. Thus if we get back + // here with recovering set and no tokens read we are + // looping on the same error recovery action. This + // happens if current_state.ParserTable is null because + // the state has an LR(0) reduction, but not all + // lookahead tokens are valid. This only occurs for + // error productions that *end* on "error". + // + // This action discards tokens one at a time until + // the looping stops. Another attack would be to always + // use the LALR(1) table if a production ends on "error" + // +#if TRACE_ACTIONS + Console.Error.WriteLine("Error: panic discard of {0}", TerminalToString(NextToken)); +#endif + if (NextToken == endOfFileToken) + return false; + NextToken = 0; + return true; + } + else + return true; + } + + /// + /// Traditional YACC method. Discards the next input token. + /// + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yyclearin" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yyclearin" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + protected void yyclearin() { NextToken = 0; } + + /// + /// Tradional YACC method. Clear the "recovering" flag. + /// + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yyerrok" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yyerrok" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + protected void yyerrok() { recovering = false; } + + /// + /// OBSOLETE FOR VERSION 1.4.0 + /// Method used by derived types to insert new + /// state instances in the "states" array. + /// + /// index of the state + /// data for the state + protected void AddState( int stateNumber, State state ) { + states[stateNumber] = state; + state.number = stateNumber; + } + + private void DisplayStack() { + Console.Error.Write( "State stack is now:" ); + for (int i = 0; i < StateStack.Depth; i++) + Console.Error.Write( " {0}", StateStack[i].number ); + Console.Error.WriteLine(); + } + + private void DisplayRule( int ruleNumber ) { + Console.Error.Write( "Reducing stack by rule {0}, ", ruleNumber ); + DisplayProduction( rules[ruleNumber] ); + } + + private void DisplayProduction( Rule rule ) { + if (rule.RightHandSide.Length == 0) + Console.Error.Write( "/* empty */ " ); + else + foreach (int symbol in rule.RightHandSide) + Console.Error.Write( "{0} ", SymbolToString( symbol ) ); + + Console.Error.WriteLine( "-> {0}", SymbolToString( rule.LeftHandSide ) ); + } + + /// + /// Abstract state class naming terminal symbols. + /// This is overridden by derived classes with the + /// name (or alias) to be used in error messages. + /// + /// The terminal ordinal + /// + protected abstract string TerminalToString( int terminal ); + + private string SymbolToString( int symbol ) { + if (symbol < 0) + return nonTerminals[-symbol - 1]; + else + return TerminalToString( symbol ); + } + + /// + /// Return text representation of argument character + /// + /// The character to convert + /// String representation of the character + protected static string CharToString( char input ) { + switch (input) { + case '\a': return @"'\a'"; + case '\b': return @"'\b'"; + case '\f': return @"'\f'"; + case '\n': return @"'\n'"; + case '\r': return @"'\r'"; + case '\t': return @"'\t'"; + case '\v': return @"'\v'"; + case '\0': return @"'\0'"; + default: return string.Format( CultureInfo.InvariantCulture, "'{0}'", input ); + } + } + } + + /// + /// Classes implementing this interface must supply a + /// method that merges two location objects to return + /// a new object of the same type. + /// GPPG-generated parsers have the default location + /// action equivalent to "@$ = @1.Merge(@N);" where N + /// is the right-hand-side length of the production. + /// + /// The Location type +#if EXPORT_GPPG + public interface IMerge +#else + internal interface IMerge +#endif + { + /// + /// Interface method that creates a location object from + /// the current and last object. Typically used to create + /// a location object extending from the start of the @1 + /// object to the end of the @N object. + /// + /// The lexically last object to merge + /// The merged location object + TSpan Merge( TSpan last ); + } + + /// + /// This is the default class that carries location + /// information from the scanner to the parser. + /// If you don't declare "%YYLTYPE Foo" the parser + /// will expect to deal with this type. + /// +#if EXPORT_GPPG + public class LexLocation : IMerge +#else + [SuppressMessage( "Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses" )] + internal class LexLocation : IMerge +#endif + { + private int startLine; // start line + private int startColumn; // start column + private int endLine; // end line + private int endColumn; // end column + + /// + /// The line at which the text span starts. + /// + public int StartLine { get { return startLine; } } + + /// + /// The column at which the text span starts. + /// + public int StartColumn { get { return startColumn; } } + + /// + /// The line on which the text span ends. + /// + public int EndLine { get { return endLine; } } + + /// + /// The column of the first character + /// beyond the end of the text span. + /// + public int EndColumn { get { return endColumn; } } + + /// + /// Default no-arg constructor. + /// + public LexLocation() { } + + /// + /// Constructor for text-span with given start and end. + /// + /// start line + /// start column + /// end line + /// end column + public LexLocation( int sl, int sc, int el, int ec ) { startLine = sl; startColumn = sc; endLine = el; endColumn = ec; } + + /// + /// Create a text location which spans from the + /// start of "this" to the end of the argument "last" + /// + /// The last location in the result span + /// The merged span + public LexLocation Merge( LexLocation last ) { return new LexLocation( this.startLine, this.startColumn, last.endLine, last.endColumn ); } + } + + /// + /// Abstract scanner class that GPPG expects its scanners to + /// extend. + /// + /// Semantic value type YYSTYPE + /// Source location type YYLTYPE +#if EXPORT_GPPG + public abstract class AbstractScanner +#else + internal abstract class AbstractScanner +#endif + where TSpan : IMerge { + /// + /// Lexical value optionally set by the scanner. The value + /// is of the %YYSTYPE type declared in the parser spec. + /// + [SuppressMessage( "Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields" )] + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yylval" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yylval" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + // A field must be declared for this value of parametric type, + // since it may be instantiated by a value struct. If it were + // implemented as a property, machine generated code in derived + // types would not be able to select on the returned value. +#pragma warning disable 649 + public TValue yylval; // Lexical value: set by scanner +#pragma warning restore 649 + + /// + /// Current scanner location property. The value is of the + /// type declared by %YYLTYPE in the parser specification. + /// + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yylloc" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yylloc" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + public virtual TSpan yylloc { + get { return default( TSpan ); } // Empty implementation allowing + set { /* skip */ } // yylloc to be ignored entirely. + } + + /// + /// Main call point for LEX-like scanners. Returns an int + /// corresponding to the token recognized by the scanner. + /// + /// An int corresponding to the token + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yylex" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yylex" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + public abstract int yylex(); + + /// + /// Traditional error reporting provided by LEX-like scanners + /// to their YACC-like clients. + /// + /// Message format string + /// Optional array of args + [SuppressMessage( "Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "yyerror" )] + [SuppressMessage( "Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "yyerror" )] + // Reason for FxCop message suppression - + // This is a traditional name for YACC-like functionality + public virtual void yyerror( string format, params object[] args ) { } + } + + /// + /// Encapsulated state for the parser. + /// Opaque to users, visible to the tool-generated code. + /// +#if EXPORT_GPPG + public class State + { + /// + /// The number of states in the automaton. + /// + public int number; +#else + internal class State { + /// + /// The index of this state in the states array. + /// + internal int number; +#endif + internal Dictionary ParserTable; // Terminal -> ParseAction + internal Dictionary Goto; // NonTerminal -> State; + internal int defaultAction; // = 0; // ParseAction + + /// + /// State transition data for this state. Pairs of elements of the + /// goto array associate symbol ordinals with next state indices. + /// The actions array is passed to another constructor. + /// + /// The action listc + /// Next state data + public State( int[] actions, int[] goToList ) + : this( actions ) { + Goto = new Dictionary(); + for (int i = 0; i < goToList.Length; i += 2) + Goto.Add( goToList[i], goToList[i + 1] ); + } + + /// + /// Action data for this state. Pairs of elements of the + /// action array associate action ordinals with each of + /// those symbols that have actions in the current state. + /// + /// The action array + public State( int[] actions ) { + ParserTable = new Dictionary(); + for (int i = 0; i < actions.Length; i += 2) + ParserTable.Add( actions[i], actions[i + 1] ); + } + + /// + /// Set the default action for this state. + /// + /// Ordinal of the default action + public State( int defaultAction ) { + this.defaultAction = defaultAction; + } + + /// + /// Set the default action and the state transition table. + /// + /// The default action + /// Transitions from this state + public State( int defaultAction, int[] goToList ) + : this( defaultAction ) { + Goto = new Dictionary(); + for (int i = 0; i < goToList.Length; i += 2) + Goto.Add( goToList[i], goToList[i + 1] ); + } + } + + /// + /// Rule representation at runtime. + /// +#if EXPORT_GPPG + public class Rule +#else + internal class Rule +#endif + { + internal int LeftHandSide; // symbol + internal int[] RightHandSide; // symbols + + /// + /// Rule constructor. This holds the ordinal of + /// the left hand side symbol, and the list of + /// right hand side symbols, in lexical order. + /// + /// The LHS non-terminal + /// The RHS symbols, in lexical order + public Rule( int left, int[] right ) { + this.LeftHandSide = left; + this.RightHandSide = right; + } + } + + /// + /// Stack utility for the shift-reduce parser. + /// GPPG parsers have three instances: + /// (1) The parser state stack, T = QUT.Gppg.State, + /// (2) The semantic value stack, T = TValue, + /// (3) The location stack, T = TSpan. + /// + /// +#if EXPORT_GPPG + public class PushdownPrefixState +#else + internal class PushdownPrefixState +#endif + { + // Note that we cannot use the BCL Stack class + // here as derived types need to index into stacks. + // + private T[] array = new T[8]; + private int tos = 0; + + /// + /// Indexer for values of the stack below the top. + /// + /// index of the element, starting from the bottom + /// the selected element + public T this[int index] { get { return array[index]; } } + + /// + /// The current depth of the stack. + /// + public int Depth { get { return tos; } } + + internal void Push( T value ) { + if (tos >= array.Length) { + T[] newarray = new T[array.Length * 2]; + System.Array.Copy( array, newarray, tos ); + array = newarray; + } + array[tos++] = value; + } + + internal T Pop() { + T rslt = array[--tos]; + array[tos] = default( T ); + return rslt; + } + + internal T TopElement() { return array[tos - 1]; } + + internal bool IsEmpty() { return tos == 0; } + } +} + diff --git a/src/DataStreamSuite/ArithmeticExpressions/Sum.cs b/src/DataStreamSuite/ArithmeticExpressions/Sum.cs new file mode 100644 index 000000000..c3c6bf449 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Sum.cs @@ -0,0 +1,45 @@ +namespace Bts.ArithmeticExpressions; + +using System.Numerics; + +class Sum : IArithmeticExpression { + readonly IArithmeticExpression left; + readonly IArithmeticExpression right; + + public Sum(IArithmeticExpression left, IArithmeticExpression right) { + this.left = left; + this.right = right; + } + + public static Sum Create( + IArithmeticExpression left, IArithmeticExpression right) + where T : INumber, IAdditionOperators => + new(left, right); + + public double Evaluate(IDictionary env) => + evaluateArg(left, nameof(left), env) + evaluateArg(right, nameof(right), env); + + static double evaluateArg( + IArithmeticExpression expr, string name, IDictionary env) { + var obj = expr.Evaluate(env); + return ConvertUtils.try_convert(expr.Evaluate(env), out double dbl) ? dbl : + throw new Exception( + $"Invalid Sum. {name} is of type {obj?.GetType()} (expected {typeof(double)})"); + } +} + +class Sum : IArithmeticExpression + where TLeft : INumber, IAdditionOperators + where TRight : INumber + where TResult : INumber { + readonly IArithmeticExpression left; + readonly IArithmeticExpression right; + + public Sum(IArithmeticExpression left, IArithmeticExpression right) { + this.left = left; + this.right = right; + } + + public TResult Evaluate(IDictionary env) => + left.Evaluate(env) + right.Evaluate(env); +} diff --git a/src/DataStreamSuite/ArithmeticExpressions/Usings.cs b/src/DataStreamSuite/ArithmeticExpressions/Usings.cs new file mode 100644 index 000000000..4de9547f0 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Usings.cs @@ -0,0 +1,4 @@ +global using System; +global using System.Linq; +global using System.Collections.Generic; +global using System.Collections.Immutable; diff --git a/src/DataStreamSuite/ArithmeticExpressions/Variable.cs b/src/DataStreamSuite/ArithmeticExpressions/Variable.cs new file mode 100644 index 000000000..0d65235b5 --- /dev/null +++ b/src/DataStreamSuite/ArithmeticExpressions/Variable.cs @@ -0,0 +1,15 @@ +namespace Bts.ArithmeticExpressions; + +using System.Collections.Generic; + +class Variable : IArithmeticExpression { + readonly string identifier; + + public Variable(string identifier) => + this.identifier = identifier; + + public object? Evaluate(IDictionary env) => + env.TryGetValue(identifier, out var val) ? val : + throw new KeyNotFoundException( + $"Failed to find {nameof(Variable)} '{identifier}'"); +} diff --git a/src/DataStreamSuite/DataStreamSuite.sln b/src/DataStreamSuite/DataStreamSuite.sln index 5566036d4..f2dfe2014 100644 --- a/src/DataStreamSuite/DataStreamSuite.sln +++ b/src/DataStreamSuite/DataStreamSuite.sln @@ -1,4 +1,4 @@ - + Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.0.31903.59 @@ -29,6 +29,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BaseUtilities", "BaseUtilit EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GuiUtilities", "GuiUtilities\GuiUtilities.csproj", "{CADBA1B3-0837-44DD-85BB-70351AD3A028}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ArithmeticExpressions", "ArithmeticExpressions\ArithmeticExpressions.csproj", "{EFE6AD17-2564-43A1-B0E5-A2A8DA173002}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU diff --git a/src/client/spark_core/Collections/Extensions/EnumerableExtensions.cs b/src/client/spark_core/Collections/Extensions/EnumerableExtensions.cs index ecf9b861f..84b4716cc 100644 --- a/src/client/spark_core/Collections/Extensions/EnumerableExtensions.cs +++ b/src/client/spark_core/Collections/Extensions/EnumerableExtensions.cs @@ -1295,6 +1295,9 @@ namespace System.Collections.Generic { } } + public static IEnumerable WhereNot(this IEnumerable source, Func predicate) => + source.Where(v => !predicate(v)); + public static IEnumerable<(T, int)> ZipIndex(this IEnumerable source) { int i = 0; foreach (var v in source) {