public IErrorReporter ErrorUsingFunctionAsProperty()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
// when writing this test compiler crashed when the function was called like a property
var env = Skila.Language.Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
NameReference func_name = NameReference.Create("b", NameFactory.IIterableCount);
root_ns.AddBuilder(FunctionBuilder.Create("bad_call", NameFactory.SizeNameReference(), Block.CreateStatement(
// using function like a property (error)
// todo: however it should be another error, because this reference should create functor and the error should
// say about type mismatch between returning value and result type
Return.Create(func_name)))
.Parameters(FunctionParameter.Create("b", NameFactory.ReferenceNameReference(NameFactory.Nat8NameReference()),
Variadic.Create(2, 3), null, false))
.Include(NameFactory.LinqExtensionReference()));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.UndefinedTemplateArguments, func_name));
}
return(resolver);
}
public static FunctionParameter Create(string name, INameReference typeName, Variadic variadic,
IExpression defaultValue,
bool isNameRequired = false,
ExpressionReadMode usageMode = ExpressionReadMode.ReadRequired)
{
return(new FunctionParameter(usageMode, name, typeName,
variadic, defaultValue, null, isNameRequired: isNameRequired));
}
public static ExecutionResult createResultInstance(Variadic resultValue)
{
ExecutionResult executionResult;
executionResult = new ExecutionResult();
executionResult.resultState = EnumResultState.RESULT;
executionResult.resultValue = resultValue;
return(executionResult);
}
/**
* converts the vector graphic vectorParts (only one edge)
* to a variadic graph, which is compatible with the rest of the system
*
*/
private static Variadic convertVectorPartsToGraph(List <VectorPart> vectorParts)
{
Variadic resultGraph;
int vertexCounter;
resultGraph = new Variadic(Variadic.EnumType.ARRAY);
resultGraph.valueArray.Add(new Variadic(Variadic.EnumType.ARRAY));
resultGraph.valueArray.Add(new Variadic(Variadic.EnumType.ARRAY));
resultGraph.valueArray.Add(new Variadic(Variadic.EnumType.ARRAY));
List <Variadic> arrayWithEdges = resultGraph.valueArray[0].valueArray;
List <Variadic> arrayWithVertices = resultGraph.valueArray[1].valueArray;
vertexCounter = 0;
foreach (VectorPart iterationVectorPart in vectorParts)
{
List <Variadic> createdEdgeArray;
Variadic createdEdgeVariadic;
Variadic createdVertexA;
Variadic createdVertexB;
// add the edge
createdEdgeArray = new List <Variadic>();
createdEdgeArray.Add(new Variadic(Variadic.EnumType.INT));
createdEdgeArray.Add(new Variadic(Variadic.EnumType.INT));
createdEdgeArray[0].valueInt = vertexCounter;
createdEdgeArray[0].valueInt = vertexCounter + 1;
createdEdgeVariadic = new Variadic(Variadic.EnumType.ARRAY);
createdEdgeVariadic.valueArray = createdEdgeArray;
arrayWithEdges.Add(createdEdgeVariadic);
// add the vertices
createdVertexA = new Variadic(Variadic.EnumType.ARRAY);
createdVertexA.valueArray.Add(new Variadic(Variadic.EnumType.FLOAT));
createdVertexA.valueArray.Add(new Variadic(Variadic.EnumType.FLOAT));
createdVertexA.valueArray[0].valueFloat = iterationVectorPart.a.x;
createdVertexA.valueArray[1].valueFloat = iterationVectorPart.a.y;
createdVertexB = new Variadic(Variadic.EnumType.ARRAY);
createdVertexB.valueArray.Add(new Variadic(Variadic.EnumType.FLOAT));
createdVertexB.valueArray.Add(new Variadic(Variadic.EnumType.FLOAT));
createdVertexB.valueArray[0].valueFloat = iterationVectorPart.b.x;
createdVertexB.valueArray[1].valueFloat = iterationVectorPart.b.y;
arrayWithVertices.Add(createdVertexA);
arrayWithVertices.Add(createdVertexB);
vertexCounter += 2;
}
return(resultGraph);
}
internal void LiveSetup(ComputationContext ctx, Variadic variadic)
{
if (this.prepared)
{
throw new Exception("Something wrong?");
}
RouteSetup(variadic.MinLimit, variadic.HasUpperLimit ? variadic.Max1Limit : (int?)null);
this.expr.Evaluated(ctx, EvaluationCall.AdHocCrossJump);
}
private static Variadic checkArrayAndVectorize(Variadic array)
{
List <VectorPart> vectorParts;
Variadic resultGraph;
// TODO check array for being an array, containing arrays of bool which have the same length
vectorParts = vectorizeBitmap(array);
resultGraph = convertVectorPartsToGraph(vectorParts);
return(resultGraph);
}
/**
*
* the array must be checked that it is a array
* the array must be checked that the width of the bitmap is consistent
* the values must be checked that they are boolean
*
*/
private static List <VectorPart> vectorizeBitmap(Variadic array)
{
List <VectorPart> resultVectorParts;
int arrayYI;
int arraySizeX;
resultVectorParts = new List <VectorPart>();
System.Diagnostics.Debug.Assert(array.valueArray.Count >= 3);
arraySizeX = array.valueArray[0].valueArray.Count;
for (arrayYI = 1; arrayYI < array.valueArray.Count - 1; arrayYI++)
{
int arrayXI;
List <Variadic> arrayYM1 = array.valueArray[arrayYI - 1].valueArray;
List <Variadic> arrayYP0 = array.valueArray[arrayYI].valueArray;
List <Variadic> arrayYP1 = array.valueArray[arrayYI + 1].valueArray;
// we let catch all indexing errors and so on by the runtime
for (arrayXI = 1; arrayXI < arrayYP0.Count - 1; arrayXI++)
{
if (!arrayYP0[arrayXI].valueBool)
{
continue;
}
// if we are here the middle pixel is true
int deltaX;
int deltaY;
for (deltaY = -1; deltaY < 1; deltaY++)
{
for (deltaX = -1; deltaX < 1; deltaX++)
{
if (deltaX == 0 && deltaY == 0)
{
continue;
}
// else we are here
if (array.valueArray[arrayYI + deltaY].valueArray[arrayXI + deltaX].valueBool)
{
resultVectorParts.Add(getVectorpartForPositionPlusDelta(arrayXI, arrayYI, deltaX, deltaY));
}
}
}
}
}
return(resultVectorParts);
}
/// <summary>
/// Returns a hash code for the <see cref="LSLParameterSignature" /> object.
/// The hash code is generated from the parameter Type, Name, ParameterIndex and Variadic status.
/// </summary>
/// <returns>The generated hash code.</returns>
public override int GetHashCode()
{
unchecked
{
var hash = 17;
hash = hash * 31 + Type.GetHashCode();
hash = hash * 31 + Name.GetHashCode();
hash = hash * 31 + ParameterIndex.GetHashCode();
hash = hash * 31 + Variadic.GetHashCode();
return(hash);
}
}
override public ExecutionResult executeSingleStep(OperatorInstance instance)
{
EnumOperationState operationState;
operationState = (EnumOperationState)instance.operationState;
if (operationState == EnumOperationState.EXECUTELEFTOPERAND)
{
return(Operator.ExecutionResult.createExecuteInstance(instance.calleeOperatorInstances[0]));
}
else if (operationState == EnumOperationState.EXECUTERIGHTOPERAND)
{
return(Operator.ExecutionResult.createExecuteInstance(instance.calleeOperatorInstances[1]));
}
else // operationState == EnumOperationState.execute
{
bool resultAsFloat;
Variadic resultVariadic;
resultVariadic = null;
resultAsFloat = instance.calleeResults[0].type == Variadic.EnumType.FLOAT || instance.calleeResults[1].type == Variadic.EnumType.FLOAT;
if (resultAsFloat)
{
float a, b, floatResult;
a = getVariadicAsFloat(instance.calleeResults[0]);
b = getVariadicAsFloat(instance.calleeResults[1]);
floatResult = a + b;
resultVariadic = new Variadic(Variadic.EnumType.FLOAT);
resultVariadic.valueFloat = floatResult;
}
else
{
int a, b, intResult;
a = instance.calleeResults[0].valueInt;
b = instance.calleeResults[1].valueInt;
intResult = a + b;
resultVariadic = new Variadic(Variadic.EnumType.INT);
resultVariadic.valueInt = intResult;
}
return(ExecutionResult.createResultInstance(resultVariadic));
}
}
static private float getVariadicAsFloat(Variadic value)
{
if (value.type == Variadic.EnumType.FLOAT)
{
return(value.valueFloat);
}
else if (value.type == Variadic.EnumType.INT)
{
return((float)value.valueInt);
}
else
{
throw new Exception("Can't convert varidic to float!");
}
}
static void Main(string[] args)
{
Variadic v = new Variadic();
int numberOne;
do
{
Console.WriteLine("Number One?");
} while (!Int32.TryParse(Console.ReadLine(), out numberOne));
int numberTwo;
Console.WriteLine("Number Two (optional)?");
Int32.TryParse(Console.ReadLine(), out numberTwo);
Console.WriteLine(v.MathOperation(numberOne, numberTwo));
Console.WriteLine("_____________________________");
do
{
Console.WriteLine("Number One?");
} while (!Int32.TryParse(Console.ReadLine(), out numberOne));
Console.WriteLine("Number Two (optional)?");
Int32.TryParse(Console.ReadLine(), out numberTwo);
Console.WriteLine(v.MathOperation(numberOne, numberTwo));
Console.WriteLine("_____________________________");
do
{
Console.WriteLine("Number One?");
} while (!Int32.TryParse(Console.ReadLine(), out numberOne));
Console.WriteLine("Number Two (optional, will ignore)?");
Int32.TryParse(Console.ReadLine(), out numberTwo);
Console.WriteLine(v.MathOperation(numberOne));
Console.ReadLine();
}
private void propagateResultDown(Variadic value)
{
OperatorInstance operatorInstanceBelow;
System.Diagnostics.Debug.Assert(operatorStack.Count >= 1);
// check if it is at the bottom of the stack
// if it is the case we return the result to the environment
if (operatorStack.Count == 1)
{
executionResult = value;
return;
}
// TODO< check if it is at the bottom of the stack > if so, write result to result value >
// else
StackElement stackElementBelow = operatorStack[operatorStack.Count - 2];
operatorInstanceBelow = stackElementBelow.operatorInstance;
operatorInstanceBelow.getCorrespondingOperator().feedOperatorInstanceResult(operatorInstanceBelow, value);
}
public IErrorReporter ErrorViolatingAssociatedReference()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
FunctionDefinition first_constructor = FunctionBuilder.CreateInitConstructor(Block.CreateStatement())
.SetModifier(EntityModifier.UnchainBase)
.Parameters(FunctionParameter.Create("y", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead),
FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead));
FunctionDefinition second_constructor = FunctionBuilder.CreateInitConstructor(Block.CreateStatement())
.SetModifier(EntityModifier.UnchainBase)
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead));
VariableDeclaration first_field = VariableDeclaration.CreateStatement("a",
NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
Undef.Create(), env.Options.ReassignableModifier() | EntityModifier.Public);
VariableDeclaration second_field = VariableDeclaration.CreateStatement("b", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
Undef.Create(), EntityModifier.Public);
TypeDefinition type = root_ns.AddBuilder(TypeBuilder.Create("Hi")
.SetModifier(EntityModifier.Base | EntityModifier.AssociatedReference | EntityModifier.Mutable)
.With(first_field)
.With(second_field)
.With(first_constructor)
.With(second_constructor));
NameReference parameter_typename = NameFactory.Int64NameReference();
root_ns.AddBuilder(TypeBuilder.Create("HelloValue")
.SetModifier(EntityModifier.AssociatedReference | EntityModifier.Mutable)
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement())
.SetModifier(EntityModifier.UnchainBase)
.Parameters(FunctionParameter.Create("x", parameter_typename, ExpressionReadMode.CannotBeRead))));
FunctionParameter variadic_param = FunctionParameter.Create("x", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
Variadic.Create(2, 6), null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead);
root_ns.AddBuilder(TypeBuilder.Create("HelloVariadic")
.SetModifier(EntityModifier.AssociatedReference | EntityModifier.Mutable)
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement())
.SetModifier(EntityModifier.UnchainBase)
.Parameters(variadic_param)));
FunctionParameter optional_param = FunctionParameter.Create("x", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
Variadic.None, Int64Literal.Create("0"), isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead);
root_ns.AddBuilder(TypeBuilder.Create("HelloOptional")
.SetModifier(EntityModifier.AssociatedReference | EntityModifier.Mutable)
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement())
.SetModifier(EntityModifier.UnchainBase)
.Parameters(optional_param)));
VariableDeclaration value_decl = VariableDeclaration.CreateStatement("v", null,
ExpressionFactory.StackConstructor("Hi", Int64Literal.Create("3")));
root_ns.AddBuilder(FunctionBuilder.Create("notimportant",
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(),
Block.CreateStatement(
value_decl,
ExpressionFactory.Readout("v")
)));
resolver = NameResolver.Create(env);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresSealedType, type.Modifier));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresSingleParameter, first_constructor));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresSingleConstructor, second_constructor));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ReferenceFieldCannotBeReassignable, first_field));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresSingleReferenceField, second_field));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresReferenceParameter, parameter_typename));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresNonVariadicParameter, variadic_param));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresNonOptionalParameter, optional_param));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssociatedReferenceRequiresPassingByReference, value_decl));
Assert.AreEqual(9, resolver.ErrorManager.Errors.Count);
}
return(resolver);
}
public IErrorReporter PreferringNonVariadicFunction()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
GlobalVariables = true, RelaxedMode = true
}.SetMutability(mutability));
var root_ns = env.Root;
var system_ns = env.SystemNamespace;
FunctionDefinition func_def1 = root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(),
Variadic.Create(), null, false, usageMode: ExpressionReadMode.CannotBeRead)));
FunctionDefinition func_def2 = root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), usageMode: ExpressionReadMode.CannotBeRead)));
root_ns.AddNode(VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), Undef.Create()));
var call = FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(NameReference.Create("i")));
root_ns.AddNode(VariableDeclaration.CreateStatement("x", NameFactory.RealNameReference(),
call, modifier: EntityModifier.Public));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
Assert.AreEqual(func_def2, call.Resolution.TargetFunctionInstance.Target);
}
return(resolver);
}
private FunctionParameter(ExpressionReadMode readMode, string name, INameReference typeName, Variadic variadic,
IExpression defaultValue, EntityModifier modifier, bool isNameRequired)
{
this.UsageMode = readMode;
this.Modifier = modifier ?? EntityModifier.None;
this.Name = NameDefinition.Create(name);
this.IsNameRequired = isNameRequired;
this.Variadic = variadic;
this.ElementTypeName = typeName;
if (this.IsVariadic)
{
this.TypeName = NameFactory.ReferenceNameReference(NameFactory.ISequenceNameReference(this.ElementTypeName,
mutability: TypeMutability.ForceMutable));
}
else
{
this.TypeName = this.ElementTypeName;
}
this.defaultValue = defaultValue;
this.instancesCache = new EntityInstanceCache(this, () => GetInstance(TypeMutability.None,
TemplateTranslation.CreateParameterless(this), Lifetime.Timeless));
this.attachPostConstructor();
}
public IInterpreter OptionalNoLimitsVariadicFunction()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create("provider", NameFactory.ChunkNameReference(NameFactory.Int64NameReference()),
Block.CreateStatement(
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.StackConstructor(NameFactory.ChunkNameReference(NameFactory.Int64NameReference()),
FunctionArgument.Create(NatLiteral.Create("2")))),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("x"), FunctionArgument.Create(NatLiteral.Create("0"))),
Int64Literal.Create("-6")),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("x"), FunctionArgument.Create(NatLiteral.Create("1"))),
Int64Literal.Create("8")),
Return.Create(NameReference.Create("x"))
)));
root_ns.AddBuilder(FunctionBuilder.Create(
"sum",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// let i0 = n.at(0)
VariableDeclaration.CreateStatement("i0", null, FunctionCall.Create(NameReference.Create("n", NameFactory.PropertyIndexerName),
FunctionArgument.Create(NatLiteral.Create("0")))),
// let i1 = n.at(1)
VariableDeclaration.CreateStatement("i1", null, FunctionCall.Create(NameReference.Create("n", NameFactory.PropertyIndexerName),
FunctionArgument.Create(NatLiteral.Create("1")))),
// return i0+i1
Return.Create(ExpressionFactory.Add("i0", "i1"))
}))
.Parameters(FunctionParameter.Create("n", NameFactory.Int64NameReference(), Variadic.Create(),
FunctionCall.Create(NameReference.Create("provider")), isNameRequired: false)));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
Return.Create(FunctionCall.Create(NameReference.Create("sum")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter CommandLine()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(
ExpressionFactory.AssertEqual(StringLiteral.Create(Interpreter.Interpreter.CommandLineTestProgramPath),
NameReference.Create(NameFactory.CommandLineProgramPath)),
ExpressionFactory.AssertEqual(StringLiteral.Create(Interpreter.Interpreter.CommandLineTestArgument),
FunctionCall.Create(NameReference.Create(NameFactory.CommandLineArguments, NameFactory.AtFunctionName),
NatLiteral.Create("0"))),
Return.Create(Nat8Literal.Create("0"))
)).
Parameters(FunctionParameter.Create(NameFactory.CommandLineProgramPath,
NameFactory.StringPointerNameReference(TypeMutability.ReadOnly)),
FunctionParameter.Create(NameFactory.CommandLineArguments,
NameFactory.StringPointerNameReference(TypeMutability.ReadOnly), Variadic.Create(), null, isNameRequired: false)));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)0, result.RetValue.PlainValue);
}
return(interpreter);
}
// gets called from the executive if a (requested execution) operator(instance) was executed abstract public void feedOperatorInstanceResult(OperatorInstance instance, Variadic result);
public IErrorReporter ErrorInvalidDefinitions()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
Extension ext = root_ns.AddNode(Extension.Create());
// `this` parameter as the second one --> error
FunctionParameter second_this_param = FunctionParameter.Create("y",
NameFactory.ReferenceNameReference(NameFactory.Nat8NameReference()), EntityModifier.This);
ext.AddBuilder(FunctionBuilder.Create("second_this", NameFactory.Nat8NameReference(), Block.CreateStatement(
Return.Create(ExpressionFactory.Mul("x", "y"))))
.Parameters(FunctionParameter.Create("x", NameFactory.ReferenceNameReference(NameFactory.Nat8NameReference())),
second_this_param));
// `this` parameter as optional one --> error
FunctionParameter opt_this_param = FunctionParameter.Create("a",
NameFactory.ReferenceNameReference(NameFactory.Nat8NameReference()), Variadic.None,
Nat8Literal.Create("0"), false, EntityModifier.This);
ext.AddBuilder(FunctionBuilder.Create("opt_this", NameFactory.Nat8NameReference(), Block.CreateStatement(
Return.Create(ExpressionFactory.Mul("a", "a"))))
.Parameters(opt_this_param));
// variadic `this` parameter --> error
FunctionParameter variadic_this_param = FunctionParameter.Create("b",
NameFactory.ReferenceNameReference(NameFactory.Nat8NameReference()),
Variadic.Create(2, 3), null, false, EntityModifier.This);
FunctionCall b_count = FunctionCall.Create(NameReference.Create("b", NameFactory.IIterableCount));
ext.AddBuilder(FunctionBuilder.Create("variadic_this", NameFactory.SizeNameReference(),
Block.CreateStatement(
// this is invalid as well, because it would mean we array of references and we try to make
// a template function (`count`) executed with reference as its template argument
// return b.count()
Return.Create(b_count)))
.Parameters(variadic_this_param)
.Include(NameFactory.LinqExtensionReference()));
// `this` parameter as value (no reference) --> error
FunctionParameter value_this_param = FunctionParameter.Create("c", NameFactory.Nat8NameReference(), EntityModifier.This);
ext.AddBuilder(FunctionBuilder.Create("value_this", NameFactory.Nat8NameReference(), Block.CreateStatement(
Return.Create(ExpressionFactory.Mul("c", "c"))))
.Parameters(value_this_param));
resolver = NameResolver.Create(env);
Assert.AreEqual(5, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NonPrimaryThisParameter, second_this_param));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.OptionalThisParameter, opt_this_param));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.VariadicThisParameter, variadic_this_param));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NonReferenceThisParameter, value_this_param));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ReferenceAsTypeArgument, b_count.Name.TemplateArguments.Single()));
}
return(resolver);
}
private static void compareValuesWithNotificationAndStoreResultInStatistics(CommunicationChannel communicationChannel, OperatorStatistics statistics, ExternalOperator calledOperator, Variadic left, Variadic right)
{
List <Variadic> operatorParameters;
Variadic operatorResult;
operatorParameters = new List <Variadic>();
operatorParameters.Add(left);
operatorParameters.Add(right);
operatorResult = callExternalOperatorAndSignalOnCommunicationChannel(communicationChannel, calledOperator, operatorParameters);
// the result is supposed to be binary
// TODO< other types? >
System.Diagnostics.Debug.Assert(operatorResult.type == Variadic.EnumType.BOOL);
statistics.addBool(operatorResult.valueBool);
}
public IErrorReporter ConflictingVariadicOverload()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), Variadic.Create(1, 3),
null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead)));
root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), Variadic.Create(3, 5),
null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count());
Assert.AreEqual(ErrorCode.OverloadingDuplicateFunctionDefinition, resolver.ErrorManager.Errors.Single().Code);
}
return(resolver);
}
public VariadicPipeFunction(Variadic fn)
{
this.fn = fn;
}
public void resetExecution()
{
executionResult = null;
}
/// <summary>
/// Creates a pipe function that takes arbitrary number of arguments or function arguments.
/// </summary>
/// <param name="fn">A delegate that encapsulates a method that match the signature of <see cref="Variadic"/>.</param>
/// <returns>The constructed pipe function that can be invoked with a given pipe context.</returns>
public static PipeFunction Create(Variadic fn)
{
CommonHelper.ConfirmNotNull(fn, "fn");
return(new VariadicPipeFunction(fn));
}
// gets called from the executive if a (requested execution) operator(instance) was executed
override public void feedOperatorInstanceResult(OperatorInstance instance, Variadic result)
{
instance.calleeResults.Add(result);
instance.operationState++;
}
// gets called from the executive if a (requested execution) operator(instance) was executed override public void feedOperatorInstanceResult(OperatorInstance instance, Variadic result);
public IErrorReporter ErrorVariadicParametersInvalidLimits()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
GlobalVariables = true, RelaxedMode = true
}.SetMutability(mutability));
var root_ns = env.Root;
var param1 = FunctionParameter.Create("x", NameFactory.Int64NameReference(), Variadic.Create(4, 3), null,
isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead);
var func_def = root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(param1));
root_ns.AddNode(VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), null, EntityModifier.Public));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.InvalidVariadicLimits, param1));
}
return(resolver);
}
