public override void Generate(Generator generator) { base.Generate(generator); parent.Generate(generator); TypeReference parentType = parent.TypeReference; generator.Symbols.Source(generator.Assembler.Region.CurrentLocation, this); generator.Assembler.PushValue(); FunctionTypeReference callType = (FunctionTypeReference)parentType; List <TypeReference> callParameters = callType.FunctionParameters; int idx = 0; foreach (Expression parameter in parameters) { parameter.Generate(generator); callParameters[idx].GenerateConversion(parameter, generator, parameter.TypeReference); idx++; generator.Assembler.PushValue(); } generator.Symbols.Source(generator.Assembler.Region.CurrentLocation, this); Placeholder retSite = generator.Assembler.CallFromStack(parameters.Count); if (generator.Resolver.CurrentDefinition != null) { generator.AddCallTraceEntry(retSite, this, generator.Resolver.CurrentDefinition.Name.DataModifierLess, generator.Resolver.CurrentFieldName); } }
public override bool Equals(object obj) { FunctionTypeReference tr = obj as FunctionTypeReference; if (tr == null) { return(false); } if (!returnType.Equals(tr.returnType)) { return(false); } if (parameters.Count != tr.parameters.Count) { return(false); } for (int i = 0; i < parameters.Count; ++i) { if (!parameters[i].Equals(tr.parameters[i])) { return(false); } } return(true); }
public override bool SupportsImplicit(TypeReference value) { if (value == null) { return(true); } if (value is NullableTypeReference) { return(false); } FunctionTypeReference tr = value as FunctionTypeReference; if (tr == null) { return(false); } if (!returnType.SupportsImplicit(tr.returnType)) { return(false); } if (parameters.Count != tr.parameters.Count) { return(false); } for (int i = 0; i < parameters.Count; ++i) { if (!parameters[i].SupportsImplicit(tr.parameters[i])) { return(false); } } return(true); }
public override void Prepare(Generator generator, TypeReference inferredType) { base.Prepare(generator, inferredType); FunctionTypeReference ftr = null; if (inferredType is FunctionTypeReference) { ftr = (FunctionTypeReference)inferredType; } if (ftr != null) { returnType = ftr.ReturnType; for (int i = 0; (i < ftr.FunctionParameters.Count) && (i < parameters.Count); ++i) { if (parameterTypes[i] == null) { parameterTypes[i] = ftr.FunctionParameters[i]; } } } for (int i = 0; i < parameterTypes.Count; ++i) { if (parameterTypes[i] == null) { throw new CompilerException(this, Resource.TypeOfExpressionUnclear); } } if (returnType == null) { throw new CompilerException(this, Resource.TypeOfExpressionUnclear); } }
public override void Prepare(Generator generator, TypeReference inferredType) { base.Prepare(generator, inferredType); if (NeedsInference(generator, inferredType)) { for (int i = 0; i < parameters.Count; ++i) { if (parameterTypes[i] == null) { parameters[i].Prepare(generator, null); parameterTypes[i] = parameters[i].TypeReference; } } } TypeReference inferred = new FunctionTypeReference(this, inferredType, parameterTypes, true); parent.Prepare(generator, inferred); TypeReference parentType = parent.TypeReference; if (!parentType.IsFunction) { throw new CompilerException(this, string.Format(Resource.Culture, Resource.CannotUseExpressionOfTypeAsFunction, parent.TypeReference.TypeName.Data)); } FunctionTypeReference callType = (FunctionTypeReference)parentType; List <TypeReference> callParameters = callType.FunctionParameters; if (parameters.Count != callParameters.Count) { throw new CompilerException(this, string.Format(Resource.Culture, Resource.FunctionCallParameterCountMismatch, ParameterListString(callParameters), parameters.Count)); } for (int i = 0; i < parameters.Count; ++i) { if (parameterTypes[i] == null) { parameters[i].Prepare(generator, callParameters[i]); parameterTypes[i] = parameters[i].TypeReference; } } type = callType.ReturnType; }
protected override bool InnerNeedsInference(Generator generator, TypeReference inferredHint) { foreach (Expression parameter in parameters) { if (!parameter.NeedsInference(generator, null)) { parameter.Prepare(generator, null); parameterTypes.Add(parameter.TypeReference); } else { parameterTypes.Add(null); } } TypeReference inferred = new FunctionTypeReference(this, inferredHint, parameterTypes, true); return(parent.NeedsInference(generator, inferred)); }