feat: Add ArithmeticExpressions csproj
This commit is contained in:
1 parent
e4f276be2a
commit
ca95ab7a24
26 files changed
+2465
-1
No files matched your search
@@ -0,0 +1,37 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Numerics;
|
||||
|
||||
class AdditiveInverse : IArithmeticExpression<double> {
|
||||
readonly IArithmeticExpression expression;
|
||||
|
||||
public AdditiveInverse(IArithmeticExpression expression) =>
|
||||
this.expression = expression;
|
||||
|
||||
public static AdditiveInverse<T> Create<T>(IArithmeticExpression<T> expression)
|
||||
where T : INumber<T> =>
|
||||
new(expression);
|
||||
|
||||
public double Evaluate(IDictionary<string, object?> env) =>
|
||||
-evaluateArg(expression, nameof(expression), env);
|
||||
|
||||
static double evaluateArg(
|
||||
IArithmeticExpression expr, string name, IDictionary<string, object?> 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<T> : IArithmeticExpression<T>
|
||||
where T : INumber<T> {
|
||||
readonly IArithmeticExpression<T> expression;
|
||||
|
||||
public AdditiveInverse(IArithmeticExpression<T> expression) =>
|
||||
this.expression = expression;
|
||||
|
||||
public T Evaluate(IDictionary<string, object?> env) =>
|
||||
-expression.Evaluate(env);
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Numerics;
|
||||
|
||||
public static class ArithmeticExpressionExtensions {
|
||||
public static IArithmeticExpression<TResult> Add<TLeft, TRight, TResult>(
|
||||
this IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right)
|
||||
where TLeft :
|
||||
INumber<TLeft>,
|
||||
IAdditionOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> =>
|
||||
new Sum<TLeft, TRight, TResult>(left, right);
|
||||
|
||||
public static IArithmeticExpression<TResult> Subtract<TLeft, TRight, TResult>(
|
||||
this IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right)
|
||||
where TLeft :
|
||||
INumber<TLeft>,
|
||||
ISubtractionOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> =>
|
||||
new Difference<TLeft, TRight, TResult>(left, right);
|
||||
|
||||
public static IArithmeticExpression<TResult> Multiply<TLeft, TRight, TResult>(
|
||||
this IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right)
|
||||
where TLeft :
|
||||
INumber<TLeft>,
|
||||
IMultiplyOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> =>
|
||||
new Product<TLeft, TRight, TResult>(left, right);
|
||||
|
||||
public static IArithmeticExpression<TResult> Divide<TLeft, TRight, TResult>(
|
||||
this IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right)
|
||||
where TLeft :
|
||||
INumber<TLeft>,
|
||||
IDivisionOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> =>
|
||||
new Quotient<TLeft, TRight, TResult>(left, right);
|
||||
|
||||
public static IArithmeticExpression<T> Negate<T>(this IArithmeticExpression<T> expression)
|
||||
where T : INumber<T> =>
|
||||
new AdditiveInverse<T>(expression);
|
||||
}
|
||||
@@ -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<IArithmeticExpression> Arguments;
|
||||
public ImmutableList<Assignment> 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> Argument
|
||||
%type <Arguments> Arguments
|
||||
%type <Assignment> Assignment
|
||||
%type <Assignments> Assignments
|
||||
%type <Program> Program
|
||||
|
||||
%%
|
||||
|
||||
Program :
|
||||
Assignments {
|
||||
$$ = new($1);
|
||||
}
|
||||
;
|
||||
|
||||
Assignments :
|
||||
Assignment {
|
||||
$$ = ImmutableList<Assignment>.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<IArithmeticExpression>.Empty.Add($1);
|
||||
}
|
||||
| Arguments COMMA Argument {
|
||||
$$ = $1.Add($3);
|
||||
}
|
||||
;
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
%%
|
||||
@@ -0,0 +1,24 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net7.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Google.Protobuf" Version="3.24.3" />
|
||||
<PackageReference Include="YaccLexTools" Version="1.2.0" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\ExpressionCore\ExpressionCore.csproj" />
|
||||
<ProjectReference Include="..\..\client\spark_core\spark_core.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup Label="ArithmeticExpression">
|
||||
<Scanner Include="ArithmeticExpressionTokens.lex" />
|
||||
<Parser Include="ArithmeticExpressionGrammar.y" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,21 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Collections.Immutable;
|
||||
|
||||
class ArithmeticProgram : IArithmeticProgram {
|
||||
readonly ImmutableList<Assignment>? assignments;
|
||||
|
||||
public ArithmeticProgram(Assignment assignment) =>
|
||||
assignments = ImmutableList<Assignment>.Empty.Add(assignment);
|
||||
|
||||
public ArithmeticProgram(ImmutableList<Assignment> assignments) =>
|
||||
this.assignments = assignments;
|
||||
|
||||
IEnumerable<string> IArithmeticProgram.OutputIdentifiers =>
|
||||
assignments.empty_if_null()
|
||||
.Select(a => a.Identifier ?? throw new Exception("Identifier string is null"))
|
||||
.Distinct();
|
||||
|
||||
IDictionary<string, object?> IArithmeticProgram.Evaluate(IDictionary<string, object?> env) =>
|
||||
assignments.empty_if_null().Aggregate(env, (e, a) => a.Evaluate(e));
|
||||
}
|
||||
@@ -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<ArithmeticProgram> {
|
||||
public ArithmeticProgram Parse(Stream expression) =>
|
||||
new ArithmeticExpressionParserImpl().Parse(expression).Program;
|
||||
}
|
||||
}
|
||||
@@ -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<string, object?> Evaluate(IDictionary<string, object?> 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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Numerics;
|
||||
|
||||
public class Difference : IArithmeticExpression<double> {
|
||||
readonly IArithmeticExpression lhs;
|
||||
readonly IArithmeticExpression rhs;
|
||||
|
||||
public Difference(IArithmeticExpression lhs, IArithmeticExpression rhs) {
|
||||
this.lhs = lhs;
|
||||
this.rhs = rhs;
|
||||
}
|
||||
|
||||
public static Difference<T, T, T> Create<T>(
|
||||
IArithmeticExpression<T> left, IArithmeticExpression<T> right)
|
||||
where T : INumber<T>, ISubtractionOperators<T, T, T> =>
|
||||
new(left, right);
|
||||
|
||||
public double Evaluate(IDictionary<string, object?> env) =>
|
||||
evaluateArg(lhs, nameof(lhs), env) - evaluateArg(rhs, nameof(rhs), env);
|
||||
|
||||
static double evaluateArg(
|
||||
IArithmeticExpression expr, string name, IDictionary<string, object?> 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<TLeft, TRight, TResult> : IArithmeticExpression<TResult>
|
||||
where TLeft : INumber<TLeft>, ISubtractionOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> {
|
||||
readonly IArithmeticExpression<TLeft> left;
|
||||
readonly IArithmeticExpression<TRight> right;
|
||||
|
||||
public Difference(IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public TResult Evaluate(IDictionary<string, object?> env) =>
|
||||
left.Evaluate(env) - right.Evaluate(env);
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Collections;
|
||||
using System.Diagnostics.CodeAnalysis;
|
||||
|
||||
class EvaluationEnvironment : IDictionary<string, object?>, IReadOnlyDictionary<string, object?> {
|
||||
IDictionary<string, object?> outerEnv;
|
||||
IDictionary<string, object?> innerEnv = new Dictionary<string, object?>();
|
||||
int? count;
|
||||
|
||||
public EvaluationEnvironment(IDictionary<string, object?> 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<string, object?> Result =>
|
||||
innerEnv;
|
||||
|
||||
public ICollection<string> Keys =>
|
||||
new KeyCollection(outerEnv, innerEnv);
|
||||
|
||||
public ICollection<object?> 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<KeyValuePair<string, object?>> 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<string, object?> item) =>
|
||||
Add(item.Key, item.Value);
|
||||
|
||||
public void Clear() =>
|
||||
throw new NotSupportedException();
|
||||
|
||||
public bool Contains(KeyValuePair<string, object?> item) =>
|
||||
TryGetValue(item.Key, out var v) && Equals(v, item.Value);
|
||||
|
||||
public void CopyTo(KeyValuePair<string, object?>[] 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<string, object?> item) =>
|
||||
throw new NotSupportedException();
|
||||
|
||||
static int countKeys(IDictionary<string, object?> d1, IDictionary<string, object?> d2) =>
|
||||
d1.Count > d2.Count ?
|
||||
d1.Count + d2.Keys.WhereNot(d1.ContainsKey).Count() :
|
||||
d2.Count + d1.Keys.WhereNot(d2.ContainsKey).Count();
|
||||
|
||||
IEnumerable<string> IReadOnlyDictionary<string, object?>.Keys => Keys;
|
||||
IEnumerable<object?> IReadOnlyDictionary<string, object?>.Values => Values;
|
||||
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
||||
|
||||
class KeyCollection : ICollection<string> {
|
||||
readonly IDictionary<string, object?> outerEnv;
|
||||
readonly IDictionary<string, object?> innerEnv;
|
||||
|
||||
public KeyCollection(
|
||||
IDictionary<string, object?> outerEnv, IDictionary<string, object?> 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<string> 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<object?> {
|
||||
readonly IDictionary<string, object?> outerEnv;
|
||||
readonly IDictionary<string, object?> innerEnv;
|
||||
|
||||
public ValueCollection(
|
||||
IDictionary<string, object?> outerEnv, IDictionary<string, object?> 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<object?> 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();
|
||||
}
|
||||
}
|
||||
@@ -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<IArithmeticExpression>? arguments) {
|
||||
Identifier = identifier;
|
||||
Arguments = arguments;
|
||||
}
|
||||
|
||||
public string? Identifier { get; }
|
||||
public ImmutableList<IArithmeticExpression>? Arguments { get; }
|
||||
|
||||
public object? Evaluate(IDictionary<string, object?> 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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,720 @@
|
||||
// ==============================================================
|
||||
// <auto-generated>
|
||||
// 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.
|
||||
// </auto-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<string> 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 ================
|
||||
// ==============================================================
|
||||
|
||||
/// <summary>
|
||||
/// This class reads characters from a single string as
|
||||
/// required, for example, by Visual Studio language services
|
||||
/// </summary>
|
||||
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<string> 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<string> 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
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
public override void Mark() { data.Mark(bPos - 2); }
|
||||
|
||||
public override int Pos
|
||||
{
|
||||
get { return bPos; }
|
||||
set { bPos = value; }
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// 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().
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
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 =============
|
||||
// ==============================================================
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
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
|
||||
}
|
||||
@@ -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<string, object?> env);
|
||||
}
|
||||
|
||||
public interface IArithmeticExpression<T> : IArithmeticExpression where T : INumber<T> {
|
||||
new T Evaluate(IDictionary<string, object?> env);
|
||||
|
||||
object? IArithmeticExpression.Evaluate(IDictionary<string, object?> env) =>
|
||||
Evaluate(env);
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
public interface IArithmeticProgram {
|
||||
IEnumerable<string> OutputIdentifiers { get; }
|
||||
|
||||
IDictionary<string, object?> Evaluate(IDictionary<string, object?> env);
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
class IntegerConstant : IArithmeticExpression<int> {
|
||||
readonly int value;
|
||||
|
||||
public IntegerConstant(int value) =>
|
||||
this.value = value;
|
||||
|
||||
public int Evaluate(IDictionary<string, object?> env) =>
|
||||
value;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Numerics;
|
||||
|
||||
class Product : IArithmeticExpression<double> {
|
||||
readonly IArithmeticExpression left;
|
||||
readonly IArithmeticExpression right;
|
||||
|
||||
public Product(IArithmeticExpression left, IArithmeticExpression right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public static Product<T, T, T> Create<T>(
|
||||
IArithmeticExpression<T> left, IArithmeticExpression<T> right)
|
||||
where T : INumber<T>, IMultiplyOperators<T, T, T> =>
|
||||
new(left, right);
|
||||
|
||||
public double Evaluate(IDictionary<string, object?> env) =>
|
||||
evaluateArg(left, nameof(left), env) * evaluateArg(right, nameof(right), env);
|
||||
|
||||
static double evaluateArg(
|
||||
IArithmeticExpression expr, string name, IDictionary<string, object?> 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<TLeft, TRight, TResult> : IArithmeticExpression<TResult>
|
||||
where TLeft : INumber<TLeft>, IMultiplyOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> {
|
||||
readonly IArithmeticExpression<TLeft> left;
|
||||
readonly IArithmeticExpression<TRight> right;
|
||||
|
||||
public Product(IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public TResult Evaluate(IDictionary<string, object?> env) =>
|
||||
left.Evaluate(env) * right.Evaluate(env);
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Numerics;
|
||||
|
||||
class Quotient : IArithmeticExpression<double> {
|
||||
readonly IArithmeticExpression left;
|
||||
readonly IArithmeticExpression right;
|
||||
|
||||
public Quotient(IArithmeticExpression left, IArithmeticExpression right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public static Quotient<T, T, T> Create<T>(
|
||||
IArithmeticExpression<T> left, IArithmeticExpression<T> right)
|
||||
where T : INumber<T>, IDivisionOperators<T, T, T> =>
|
||||
new(left, right);
|
||||
|
||||
public double Evaluate(IDictionary<string, object?> env) =>
|
||||
evaluateArg(left, nameof(left), env) / evaluateArg(right, nameof(right), env);
|
||||
|
||||
static double evaluateArg(
|
||||
IArithmeticExpression expr, string name, IDictionary<string, object?> 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<TLeft, TRight, TResult> : IArithmeticExpression<TResult>
|
||||
where TLeft : INumber<TLeft>, IDivisionOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> {
|
||||
readonly IArithmeticExpression<TLeft> left;
|
||||
readonly IArithmeticExpression<TRight> right;
|
||||
|
||||
public Quotient(IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public TResult Evaluate(IDictionary<string, object?> env) =>
|
||||
left.Evaluate(env) / right.Evaluate(env);
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
class RealConstant : IArithmeticExpression<double> {
|
||||
readonly double value;
|
||||
|
||||
public RealConstant(double value) =>
|
||||
this.value = value;
|
||||
|
||||
public double Evaluate(IDictionary<string, object?> env) =>
|
||||
value;
|
||||
}
|
||||
@@ -0,0 +1,884 @@
|
||||
// ==============================================================
|
||||
// <auto-generated>
|
||||
// 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.
|
||||
// </auto-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 {
|
||||
/// <summary>
|
||||
/// Abstract class for GPPG shift-reduce parsers.
|
||||
/// Parsers generated by GPPG derive from this base
|
||||
/// class, overriding the abstract Initialize() and
|
||||
/// DoAction() methods.
|
||||
/// </summary>
|
||||
/// <typeparam name="TValue">Semantic value type</typeparam>
|
||||
/// <typeparam name="TSpan">Location type</typeparam>
|
||||
#if EXPORT_GPPG
|
||||
public abstract class ShiftReduceParser<TValue, TSpan>
|
||||
#else
|
||||
internal abstract class ShiftReduceParser<TValue, TSpan>
|
||||
#endif
|
||||
where TSpan : IMerge<TSpan>, new() {
|
||||
private AbstractScanner<TValue, TSpan> scanner;
|
||||
/// <summary>
|
||||
/// The abstract scanner for this parser.
|
||||
/// </summary>
|
||||
protected AbstractScanner<TValue, TSpan> Scanner {
|
||||
get { return scanner; }
|
||||
set { scanner = value; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Constructor for base class
|
||||
/// </summary>
|
||||
/// <param name="scanner">Scanner instance for this parser</param>
|
||||
protected ShiftReduceParser( AbstractScanner<TValue, TSpan> 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.
|
||||
// ==============================================================
|
||||
/// <summary>
|
||||
/// The current value of the "$$" symbolic variable in the parser
|
||||
/// </summary>
|
||||
[SuppressMessage( "Microsoft.Design", "CA1051:DoNotDeclareVisibleInstanceFields" )]
|
||||
protected TValue CurrentSemanticValue;
|
||||
|
||||
/// <summary>
|
||||
/// The current value of the "@$" symbolic variable in the parser
|
||||
/// </summary>
|
||||
[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<State> StateStack = new PushdownPrefixState<State>();
|
||||
private PushdownPrefixState<TValue> valueStack = new PushdownPrefixState<TValue>();
|
||||
private PushdownPrefixState<TSpan> locationStack = new PushdownPrefixState<TSpan>();
|
||||
|
||||
/// <summary>
|
||||
/// The stack of semantic value (YYSTYPE) values.
|
||||
/// </summary>
|
||||
protected PushdownPrefixState<TValue> ValueStack { get { return valueStack; } }
|
||||
|
||||
/// <summary>
|
||||
/// The stack of location value (YYLTYPE) varlues.
|
||||
/// </summary>
|
||||
protected PushdownPrefixState<TSpan> LocationStack { get { return locationStack; } }
|
||||
|
||||
private int errorToken;
|
||||
private int endOfFileToken;
|
||||
private string[] nonTerminals;
|
||||
private State[] states;
|
||||
private Rule[] rules;
|
||||
|
||||
/// <summary>
|
||||
/// Initialization method to allow derived classes
|
||||
/// to insert the rule list into this base class.
|
||||
/// </summary>
|
||||
/// <param name="rules">The array of Rule objects</param>
|
||||
protected void InitRules( Rule[] rules ) { this.rules = rules; }
|
||||
|
||||
/// <summary>
|
||||
/// Initialization method to allow derived classes to
|
||||
/// insert the states table into this base class.
|
||||
/// </summary>
|
||||
/// <param name="states">The pre-initialized states table</param>
|
||||
protected void InitStates( State[] states ) { this.states = states; }
|
||||
|
||||
/// <summary>
|
||||
/// OBSOLETE FOR VERSION 1.4.0
|
||||
/// </summary>
|
||||
/// <param name="size"></param>
|
||||
protected void InitStateTable( int size ) { states = new State[size]; }
|
||||
|
||||
/// <summary>
|
||||
/// Initialization method to allow derived classes
|
||||
/// to insert the special value for the error and EOF tokens.
|
||||
/// </summary>
|
||||
/// <param name="err">The error state ordinal</param>
|
||||
/// <param name="end">The EOF stat ordinal</param>
|
||||
protected void InitSpecialTokens( int err, int end ) {
|
||||
errorToken = err;
|
||||
endOfFileToken = end;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initialization method to allow derived classes to
|
||||
/// insert the non-terminal symbol names into this base class.
|
||||
/// </summary>
|
||||
/// <param name="names">Non-terminal symbol names</param>
|
||||
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.
|
||||
|
||||
/// <summary>
|
||||
/// Force parser to terminate, returning "true"
|
||||
/// </summary>
|
||||
protected static void YYAccept() { throw new AcceptException(); }
|
||||
|
||||
/// <summary>
|
||||
/// Force parser to terminate, returning "false"
|
||||
/// </summary>
|
||||
protected static void YYAbort() { throw new AbortException(); }
|
||||
|
||||
/// <summary>
|
||||
/// Force parser to terminate, returning
|
||||
/// "false" if error recovery fails.
|
||||
/// </summary>
|
||||
protected static void YYError() { throw new ErrorException(); }
|
||||
|
||||
/// <summary>
|
||||
/// Check if parser in error recovery state.
|
||||
/// </summary>
|
||||
protected bool YYRecovering { get { return recovering; } }
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Abstract base method. ShiftReduceParser calls this
|
||||
/// to initialize the base class data structures. Concrete
|
||||
/// parser classes must override this method.
|
||||
/// </summary>
|
||||
protected abstract void Initialize();
|
||||
|
||||
/// <summary>
|
||||
/// Main entry point of the Shift-Reduce Parser.
|
||||
/// </summary>
|
||||
/// <returns>True if parse succeeds, else false for
|
||||
/// unrecoverable errors</returns>
|
||||
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 );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Execute the selected action from array.
|
||||
/// Must be overriden in derived classes.
|
||||
/// </summary>
|
||||
/// <param name="actionNumber">Index of the action to perform</param>
|
||||
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;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Traditional YACC method. Discards the next input token.
|
||||
/// </summary>
|
||||
[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; }
|
||||
|
||||
/// <summary>
|
||||
/// Tradional YACC method. Clear the "recovering" flag.
|
||||
/// </summary>
|
||||
[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; }
|
||||
|
||||
/// <summary>
|
||||
/// OBSOLETE FOR VERSION 1.4.0
|
||||
/// Method used by derived types to insert new
|
||||
/// state instances in the "states" array.
|
||||
/// </summary>
|
||||
/// <param name="stateNumber">index of the state</param>
|
||||
/// <param name="state">data for the state</param>
|
||||
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 ) );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Abstract state class naming terminal symbols.
|
||||
/// This is overridden by derived classes with the
|
||||
/// name (or alias) to be used in error messages.
|
||||
/// </summary>
|
||||
/// <param name="terminal">The terminal ordinal</param>
|
||||
/// <returns></returns>
|
||||
protected abstract string TerminalToString( int terminal );
|
||||
|
||||
private string SymbolToString( int symbol ) {
|
||||
if (symbol < 0)
|
||||
return nonTerminals[-symbol - 1];
|
||||
else
|
||||
return TerminalToString( symbol );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Return text representation of argument character
|
||||
/// </summary>
|
||||
/// <param name="input">The character to convert</param>
|
||||
/// <returns>String representation of the character</returns>
|
||||
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 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <typeparam name="TSpan">The Location type</typeparam>
|
||||
#if EXPORT_GPPG
|
||||
public interface IMerge<TSpan>
|
||||
#else
|
||||
internal interface IMerge<TSpan>
|
||||
#endif
|
||||
{
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <param name="last">The lexically last object to merge</param>
|
||||
/// <returns>The merged location object</returns>
|
||||
TSpan Merge( TSpan last );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
#if EXPORT_GPPG
|
||||
public class LexLocation : IMerge<LexLocation>
|
||||
#else
|
||||
[SuppressMessage( "Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses" )]
|
||||
internal class LexLocation : IMerge<LexLocation>
|
||||
#endif
|
||||
{
|
||||
private int startLine; // start line
|
||||
private int startColumn; // start column
|
||||
private int endLine; // end line
|
||||
private int endColumn; // end column
|
||||
|
||||
/// <summary>
|
||||
/// The line at which the text span starts.
|
||||
/// </summary>
|
||||
public int StartLine { get { return startLine; } }
|
||||
|
||||
/// <summary>
|
||||
/// The column at which the text span starts.
|
||||
/// </summary>
|
||||
public int StartColumn { get { return startColumn; } }
|
||||
|
||||
/// <summary>
|
||||
/// The line on which the text span ends.
|
||||
/// </summary>
|
||||
public int EndLine { get { return endLine; } }
|
||||
|
||||
/// <summary>
|
||||
/// The column of the first character
|
||||
/// beyond the end of the text span.
|
||||
/// </summary>
|
||||
public int EndColumn { get { return endColumn; } }
|
||||
|
||||
/// <summary>
|
||||
/// Default no-arg constructor.
|
||||
/// </summary>
|
||||
public LexLocation() { }
|
||||
|
||||
/// <summary>
|
||||
/// Constructor for text-span with given start and end.
|
||||
/// </summary>
|
||||
/// <param name="sl">start line</param>
|
||||
/// <param name="sc">start column</param>
|
||||
/// <param name="el">end line </param>
|
||||
/// <param name="ec">end column</param>
|
||||
public LexLocation( int sl, int sc, int el, int ec ) { startLine = sl; startColumn = sc; endLine = el; endColumn = ec; }
|
||||
|
||||
/// <summary>
|
||||
/// Create a text location which spans from the
|
||||
/// start of "this" to the end of the argument "last"
|
||||
/// </summary>
|
||||
/// <param name="last">The last location in the result span</param>
|
||||
/// <returns>The merged span</returns>
|
||||
public LexLocation Merge( LexLocation last ) { return new LexLocation( this.startLine, this.startColumn, last.endLine, last.endColumn ); }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Abstract scanner class that GPPG expects its scanners to
|
||||
/// extend.
|
||||
/// </summary>
|
||||
/// <typeparam name="TValue">Semantic value type YYSTYPE</typeparam>
|
||||
/// <typeparam name="TSpan">Source location type YYLTYPE</typeparam>
|
||||
#if EXPORT_GPPG
|
||||
public abstract class AbstractScanner<TValue, TSpan>
|
||||
#else
|
||||
internal abstract class AbstractScanner<TValue, TSpan>
|
||||
#endif
|
||||
where TSpan : IMerge<TSpan> {
|
||||
/// <summary>
|
||||
/// Lexical value optionally set by the scanner. The value
|
||||
/// is of the %YYSTYPE type declared in the parser spec.
|
||||
/// </summary>
|
||||
[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
|
||||
|
||||
/// <summary>
|
||||
/// Current scanner location property. The value is of the
|
||||
/// type declared by %YYLTYPE in the parser specification.
|
||||
/// </summary>
|
||||
[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.
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Main call point for LEX-like scanners. Returns an int
|
||||
/// corresponding to the token recognized by the scanner.
|
||||
/// </summary>
|
||||
/// <returns>An int corresponding to the token</returns>
|
||||
[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();
|
||||
|
||||
/// <summary>
|
||||
/// Traditional error reporting provided by LEX-like scanners
|
||||
/// to their YACC-like clients.
|
||||
/// </summary>
|
||||
/// <param name="format">Message format string</param>
|
||||
/// <param name="args">Optional array of args</param>
|
||||
[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 ) { }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encapsulated state for the parser.
|
||||
/// Opaque to users, visible to the tool-generated code.
|
||||
/// </summary>
|
||||
#if EXPORT_GPPG
|
||||
public class State
|
||||
{
|
||||
/// <summary>
|
||||
/// The number of states in the automaton.
|
||||
/// </summary>
|
||||
public int number;
|
||||
#else
|
||||
internal class State {
|
||||
/// <summary>
|
||||
/// The index of this state in the states array.
|
||||
/// </summary>
|
||||
internal int number;
|
||||
#endif
|
||||
internal Dictionary<int, int> ParserTable; // Terminal -> ParseAction
|
||||
internal Dictionary<int, int> Goto; // NonTerminal -> State;
|
||||
internal int defaultAction; // = 0; // ParseAction
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <param name="actions">The action list</param>c
|
||||
/// <param name="goToList">Next state data</param>
|
||||
public State( int[] actions, int[] goToList )
|
||||
: this( actions ) {
|
||||
Goto = new Dictionary<int, int>();
|
||||
for (int i = 0; i < goToList.Length; i += 2)
|
||||
Goto.Add( goToList[i], goToList[i + 1] );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <param name="actions">The action array</param>
|
||||
public State( int[] actions ) {
|
||||
ParserTable = new Dictionary<int, int>();
|
||||
for (int i = 0; i < actions.Length; i += 2)
|
||||
ParserTable.Add( actions[i], actions[i + 1] );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set the default action for this state.
|
||||
/// </summary>
|
||||
/// <param name="defaultAction">Ordinal of the default action</param>
|
||||
public State( int defaultAction ) {
|
||||
this.defaultAction = defaultAction;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Set the default action and the state transition table.
|
||||
/// </summary>
|
||||
/// <param name="defaultAction">The default action</param>
|
||||
/// <param name="goToList">Transitions from this state</param>
|
||||
public State( int defaultAction, int[] goToList )
|
||||
: this( defaultAction ) {
|
||||
Goto = new Dictionary<int, int>();
|
||||
for (int i = 0; i < goToList.Length; i += 2)
|
||||
Goto.Add( goToList[i], goToList[i + 1] );
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Rule representation at runtime.
|
||||
/// </summary>
|
||||
#if EXPORT_GPPG
|
||||
public class Rule
|
||||
#else
|
||||
internal class Rule
|
||||
#endif
|
||||
{
|
||||
internal int LeftHandSide; // symbol
|
||||
internal int[] RightHandSide; // symbols
|
||||
|
||||
/// <summary>
|
||||
/// Rule constructor. This holds the ordinal of
|
||||
/// the left hand side symbol, and the list of
|
||||
/// right hand side symbols, in lexical order.
|
||||
/// </summary>
|
||||
/// <param name="left">The LHS non-terminal</param>
|
||||
/// <param name="right">The RHS symbols, in lexical order</param>
|
||||
public Rule( int left, int[] right ) {
|
||||
this.LeftHandSide = left;
|
||||
this.RightHandSide = right;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
#if EXPORT_GPPG
|
||||
public class PushdownPrefixState<T>
|
||||
#else
|
||||
internal class PushdownPrefixState<T>
|
||||
#endif
|
||||
{
|
||||
// Note that we cannot use the BCL Stack<T> class
|
||||
// here as derived types need to index into stacks.
|
||||
//
|
||||
private T[] array = new T[8];
|
||||
private int tos = 0;
|
||||
|
||||
/// <summary>
|
||||
/// Indexer for values of the stack below the top.
|
||||
/// </summary>
|
||||
/// <param name="index">index of the element, starting from the bottom</param>
|
||||
/// <returns>the selected element</returns>
|
||||
public T this[int index] { get { return array[index]; } }
|
||||
|
||||
/// <summary>
|
||||
/// The current depth of the stack.
|
||||
/// </summary>
|
||||
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; }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
namespace Bts.ArithmeticExpressions;
|
||||
|
||||
using System.Numerics;
|
||||
|
||||
class Sum : IArithmeticExpression<double> {
|
||||
readonly IArithmeticExpression left;
|
||||
readonly IArithmeticExpression right;
|
||||
|
||||
public Sum(IArithmeticExpression left, IArithmeticExpression right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public static Sum<T, T, T> Create<T>(
|
||||
IArithmeticExpression<T> left, IArithmeticExpression<T> right)
|
||||
where T : INumber<T>, IAdditionOperators<T, T, T> =>
|
||||
new(left, right);
|
||||
|
||||
public double Evaluate(IDictionary<string, object?> env) =>
|
||||
evaluateArg(left, nameof(left), env) + evaluateArg(right, nameof(right), env);
|
||||
|
||||
static double evaluateArg(
|
||||
IArithmeticExpression expr, string name, IDictionary<string, object?> 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<TLeft, TRight, TResult> : IArithmeticExpression<TResult>
|
||||
where TLeft : INumber<TLeft>, IAdditionOperators<TLeft, TRight, TResult>
|
||||
where TRight : INumber<TRight>
|
||||
where TResult : INumber<TResult> {
|
||||
readonly IArithmeticExpression<TLeft> left;
|
||||
readonly IArithmeticExpression<TRight> right;
|
||||
|
||||
public Sum(IArithmeticExpression<TLeft> left, IArithmeticExpression<TRight> right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public TResult Evaluate(IDictionary<string, object?> env) =>
|
||||
left.Evaluate(env) + right.Evaluate(env);
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
global using System;
|
||||
global using System.Linq;
|
||||
global using System.Collections.Generic;
|
||||
global using System.Collections.Immutable;
|
||||
@@ -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<string, object?> env) =>
|
||||
env.TryGetValue(identifier, out var val) ? val :
|
||||
throw new KeyNotFoundException(
|
||||
$"Failed to find {nameof(Variable)} '{identifier}'");
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -1295,6 +1295,9 @@ namespace System.Collections.Generic {
|
||||
}
|
||||
}
|
||||
|
||||
public static IEnumerable<T> WhereNot<T>(this IEnumerable<T> source, Func<T, bool> predicate) =>
|
||||
source.Where(v => !predicate(v));
|
||||
|
||||
public static IEnumerable<(T, int)> ZipIndex<T>(this IEnumerable<T> source) {
|
||||
int i = 0;
|
||||
foreach (var v in source) {
|
||||
|
||||
Reference in new issue
Block a user