public static Array Flatten(params object[] objs)
{
if (objs == null || objs.Length == 0)
{
return(Array.Create(new object[0]));
}
var flattened = objs.Cast <Data>().SelectMany(data => {
IEnumerable <Data> flat(object obj)
{
if (obj is ReferenceData reference)
{
return(flat(reference.UnpackReference(Compiler.RegenCompiler.CurrentContext)));
}
if (obj is Array r)
{
return(r.Values.SelectMany(flat).ToArray());
}
if (obj is IList l)
{
return(l.Cast <Data>().SelectMany(flat).ToList());
}
return(obj.YieldAs <Data>());
}
return(flat(data));
}).ToArray();
return(Array.Create(flattened));
}
/// <summary>
/// Passing [1,2] , [3,4] will result in [1,1,2,2] [3,4,3,4]
/// </summary>
/// <param name="first"></param>
/// <param name="second"></param>
/// <param name="excludeEquals"></param>
/// <returns></returns>
public static PackedArguments forevery(IList first, IList second, IList third, bool excludeEquals)
{
var retFirst = new List <object>();
var retSecond = new List <object>();
var retThird = new List <object>();
foreach (var f in first)
{
foreach (var s in second)
{
foreach (var t in third)
{
if (excludeEquals && (Equals(f, s) || Equals(f, t) || Equals(s, t)))
{
continue;
}
retFirst.Add(f);
retSecond.Add(s);
retThird.Add(t);
}
}
}
return(new PackedArguments(Array.Create(retFirst), Array.Create(retSecond), Array.Create(retThird)));
}
public void create_nested_array()
{
var @input = $@"
%a = [1,asarray(1,2,3)]
";
var variables = Variables(input).Values.Last();
variables.Should().BeOfType <Array>().Which[1].Should().BeEquivalentTo(Array.CreateParams(1, 2, 3));
}
public void declaration_new_nested_array()
{
var @input = $@"
%a = [1,asarray(1,2,3)]
";
var vars = Variables(input);
vars.Values.Last().Should().BeOfType <ReferenceData>().Which.UnpackReference(vars)
.Should().BeOfType <Array>().Which[1].Should().BeEquivalentTo(Array.CreateParams(1, 2, 3));
}
public static Array Except(IList @this, params object[] objs)
{
if (objs == null || objs.Length == 0)
{
return(Array.Create(@this));
}
var vals = @this.Cast <Data>().Where(left => objs.Any(right => !Equals(left.Value, right is Data d ? d.Value : right)));
return(Array.Create(vals));
}
public static Array Skip(IList @this, object count)
{
int intSkip = Common.ParseInt(count);
if (@this == null || @this.Count == 0)
{
return(Array.Create(@this));
}
var vals = @this.Cast <Data>().Skip(intSkip);
return(Array.Create(vals));
}
public static Array SkipTake(IList @this, object skip, object take)
{
int intSkip = Common.ParseInt(skip);
int intTake = Common.ParseInt(take);
if (@this == null || @this.Count == 0)
{
return(Array.Create(@this));
}
var vals = @this.Cast <Data>().Skip(intSkip).Take(intTake);
return(Array.Create(vals));
}
public static Array RepeatElement(object obj, object times)
{
int repeats = Common.ParseInt(times);
if (obj is ReferenceData r)
{
obj = r.Value;
}
if (obj is IList l)
{
return(Array.Create(Repeat(l.Cast <object>().Select(Data.Create), repeats)));
}
return(Array.Create(Enumerable.Repeat(obj is Data d ? d : Data.Create(obj), repeats)));
}
public static Array Concat(IList @this, params object[] objs)
{
if (objs == null || objs.Length == 0)
{
return(Array.Create(@this));
}
var flattened = objs.Cast <Data>().SelectMany(CollectionSelector);
return(Array.Create(@this.Cast <Data>().Concat(flattened)));
IEnumerable <Data> CollectionSelector(Data data)
{
if (data is Array r)
{
return((IList <Data>)r.Values);
}
if (data is IList l)
{
return((IList <Data>)l.Cast <Data>().ToList());
}
return((IList <Data>) new[] { data });
}
}
public void array_create_ints()
{
Array.CreateParams(1, 2, 3)
.Should()
.ContainInOrder(Scalar.Create(1), Scalar.Create(2), Scalar.Create(3));
}
public void array_create_singlenull()
{
Array.Create(null)
.Should()
.BeEmpty();
}
public void array_createparams_singlenull()
{
Array.CreateParams(null)
.Should()
.ContainInOrder(Scalar.Create(null));
}
public void array_create_nulls()
{
Array.CreateParams(null, null, null)
.Should()
.ContainInOrder(Scalar.Create(null), Scalar.Create(null), Scalar.Create(null));
}
/// <summary>
/// Perform the evaluation or translate <see cref="Expression"/> into a variable for later use in computation.
/// </summary>
/// <returns></returns>
private Data Compute(Expression expression, List <TemporaryVariable> temps, Type _caller = null)
{
return(_eval(expression, _caller));
Data _eval(Expression express, Type caller = null)
{
switch (express)
{
case null:
throw new NullReferenceException();
case ArgumentsExpression argumentsExpression: {
var arr = new Array();
foreach (var expr in argumentsExpression.Arguments)
{
arr.Add(_eval(expr));
}
return(arr);
}
case ArrayExpression arrayExpression: {
var arr = new Array();
foreach (var expr in arrayExpression.Values)
{
arr.Add(_eval(expr));
}
return(arr);
}
case NumberLiteral numberLiteral: {
return(new NumberScalar(_evaluate(numberLiteral.Value)));
}
case BooleanLiteral booleanLiteral: {
return(new BoolScalar(booleanLiteral.Value));
}
case CharLiteral charLiteral: {
return(new StringScalar(charLiteral.Value.ToString()));
}
case NullIdentity nullIdentity: {
return(Data.Null);
}
case StringLiteral stringLiteral: {
return(new StringScalar(stringLiteral.Value));
}
case KeyValueExpression keyValueExpression: {
//todo create a KeyValue regen data type.
return(new NetObject(new KeyValuePair <object, object>(_eval(keyValueExpression.Key), _eval(keyValueExpression.Value))));
}
case EmptyExpression emptyExpression: {
return(Data.Null);
}
case ForeachExpression foreachExpression: {
break;
}
case GroupExpression groupExpression: {
return(_eval(groupExpression.InnerExpression));
}
case ReferenceIdentity referenceIdentity: {
if (!Context.Variables.ContainsKey(referenceIdentity.Name))
{
return(new ReferenceData(referenceIdentity.Name));
}
if (!Context.Variables.TryGetValue(referenceIdentity.Name, out var value, true))
{
throw new Exception("This should never occur.");
}
//if it is not a reference, make one.
if (!(value is ReferenceData))
{
return(new ReferenceData(referenceIdentity.Name));
}
return((ReferenceData)value);
}
case PropertyIdentity propertyIdentity: {
TemporaryVariable tmp = null;
var left = _eval(propertyIdentity.Left);
if (left is ReferenceData rf)
{
var right = new PropertyIdentity(IdentityExpression.WrapVariable(rf.EmitExpressive()), propertyIdentity.Right).AsString();
return(Data.Create(_evaluate(right)));
}
//not reference
using (tmp = new TemporaryVariable(Context, left is NetObject no ? no.Value : left)) {
return(Data.Create(_evaluate($"{tmp.Name}.{propertyIdentity.Right.AsString()}")));
}
using (var var = new TemporaryVariable(Context, left is NetObject no ? no.Value : left)) {
var right = new PropertyIdentity(IdentityExpression.WrapVariable(var.Name), propertyIdentity.Right).AsString();
return(Data.Create(_evaluate(right)));
}
}
case StringIdentity stringIdentity: {
return(new ReferenceData(stringIdentity.Name));
}
case IdentityExpression identityExpression: {
return(_eval(identityExpression.Identity, caller)); //todo test
}
case Identity identity: {
throw new NotSupportedException();
}
case CallExpression callExpression: {
var left = _eval(callExpression.FunctionName, typeof(CallExpression));
var args = (Array)_eval(callExpression.Arguments);
if (left is NetObject || left is Array || left is Dictionary)
{
goto _storing;
}
//try regular parsing:
try {
var parsed = $"{left.Emit()}({args.Select(arg => arg.EmitExpressive()).StringJoin(", ")})";
return(Data.Create(_evaluate(parsed)));
} catch (ExpressionCompileException e) when(e.InnerException?.Message.Contains("FunctionCallElement: Could find not function") ?? false)
{
throw;
} catch (ExpressionCompileException) { }
_storing: //try storing left as variable
using (var var = new TemporaryVariable(Context, left is NetObject no ? no.Value : left)) {
var parsed = $"{var.Name}({args.Select(arg => arg.EmitExpressive()).StringJoin(", ")})";
return(Data.Create(_evaluate(parsed)));
}
}
case IndexerCallExpression indexerCallExpression: {
var left = Data.Create(_eval(indexerCallExpression.Left, typeof(IndexerCallExpression)));
var args = (Array)_eval(indexerCallExpression.Arguments);
if (left is NetObject || left is Array || left is Dictionary)
{
goto _storing;
}
//try regular parsing:
try {
var parsed = $"{left.Emit()}[{args.Select(arg => arg.EmitExpressive()).StringJoin(", ")}]";
return(Data.Create(_evaluate(parsed)));
} catch (ExpressionCompileException) { }
_storing: //try storing left as variable
using (var var = new TemporaryVariable(Context, left is NetObject no ? no.Value : left)) {
var parsed = $"{var.Name}[{args.Select(arg => arg.EmitExpressive()).StringJoin(", ")}]";
return(Data.Create(_evaluate(parsed)));
}
}
case NewExpression newExpression: {
//todo new
break;
}
case LeftOperatorExpression leftOperatorExpression: {
foreach (var e in leftOperatorExpression.Iterate())
{
if (e is ArrayExpression)
{
throw new NotSupportedException("Unable to compile a nested array, please define it in a variable first.");
}
}
//todo BuiltinTests.len fails here because we do not expand left or right. we should.
return(Data.Create(_evaluate(leftOperatorExpression.AsString())));
}
case OperatorExpression operatorExpression: {
foreach (var e in operatorExpression.Iterate())
{
if (e is ArrayExpression)
{
throw new NotSupportedException("Unable to compile a nested array, please define it in a variable first.");
}
}
//todo BuiltinTests.len fails here because we do not expand left or right. we should.
return(Data.Create(_evaluate(operatorExpression.AsString())));
}
case RightOperatorExpression rightOperatorExpression: {
foreach (var e in rightOperatorExpression.Iterate())
{
if (e is ArrayExpression)
{
throw new NotSupportedException("Unable to compile a nested array, please define it in a variable first.");
}
}
//todo BuiltinTests.len fails here because we do not expand left or right. we should.
return(Data.Create(_evaluate(rightOperatorExpression.AsString())));
}
case ThrowExpression throwExpression: {
break;
}
case VariableDeclarationExpression variableExpression: {
var name = Data.Create(_eval(variableExpression.Name));
if (name.GetType() != typeof(StringScalar))
{
throw new NotSupportedException("Variable names can contain only _azAZ0-9");
}
var value = Data.Create(_eval(variableExpression.Right));
Context.Variables[name.ToString()] = value;
return(value);
}
}
return(Data.Null);
}
}
public static int len(Array arr)
{
return(arr.Count);
}
public static Array asarray(params object[] objs)
{
return(Array.CreateParams(objs));
}
