public void GreaterThanOrEqualToIntegerNegativeAssertion() { string expression = "${MyVariable>=12}"; string key = "MyVariable"; string val = "11"; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.IsFalse((bool)resolved_exp.ResolvedValue); }
public void AdditionAssertion() { string expression = "${MyVariable+24}"; string key = "MyVariable"; int val = 12; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((int)resolved_exp.ResolvedValue, (12 + 24)); }
public void CompoundPrecedenceAssertion() { string expression = "${MyVariable+24*8}"; string key = "MyVariable"; string val = "48"; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((string)resolved_exp.ResolvedValue, ("48192")); }
public void CompoundOverridePrecedenceAssertion() { string expression = "${(MyVariable+24)*8}"; string key = "MyVariable"; int val = 48; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((int)resolved_exp.ResolvedValue, ((48 + 24) * 8)); }
public void TernaryOperationAssertion() { string expression = "${MyVariable==48?'y' + 'e' + 's':'n' + 'o'}"; string key = "MyVariable"; int val = 48; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((string)resolved_exp.ResolvedValue, "yes"); }
public void LeftSideStringAdditionAssertion() { string expression = "${'abc'+MyVariable}"; string key = "MyVariable"; string val = "def"; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((string)resolved_exp.ResolvedValue, "abc" + "def"); }
public void CompoundSubtractionAssertion() { string expression = "${MyVariable-24-8}"; string key = "MyVariable"; int val = 48; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((int)resolved_exp.ResolvedValue, (48 - 24 - 8)); }
public void ListRightSideStringAdditionAssertion() { string expression = "${MyVariable[0]+'def'}"; string key = "MyVariable"; string[] val = { "abc" }; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((string)resolved_exp.ResolvedValue, "abc" + "def"); }
public void ListSubtractionAssertion() { string expression = "${MyVariable[0]-24}"; string key = "MyVariable"; int[] val = { 12 }; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.AreEqual((int)resolved_exp.ResolvedValue, (12 - 24)); }
public void ListGreaterThanOrEqualToIntegerPositiveAssertion() { string expression = "${MyVariable[0]>=12}"; string key = "MyVariable"; int[] val = { 13 }; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.IsTrue((bool)resolved_exp.ResolvedValue); }
public void EqualsStringPositiveAssertion() { string expression = "${MyVariable=='asdf'}"; string key = "MyVariable"; string val = "asdf"; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.IsTrue((bool)(resolved_exp.ResolvedValue)); }
public void EqualsIntegerPositiveAssertion() { string expression = "${MyVariable==10}"; string key = "MyVariable"; int val = 10; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.IsTrue((bool)resolved_exp.ResolvedValue); }
public void MixedDataLiteralEquivilencyEvaluations(int dataIntVal, double dataDoubleVal, string expression, bool expectedResult) { DataContext dc = new DataContext(); SimpleExpressionResolverDataObject dataObject = new SimpleExpressionResolverDataObject(dataIntVal, "Top Object", dataDoubleVal); string key = "foo"; dc.RegisterDataItem(key, dataObject); ResolvedExpression result = Engine.ResolveExpression(expression, dc); Assert.AreEqual(ResolvedExpression.booleanType, result.ResolvedType); Assert.AreEqual(expectedResult, result.ResolvedValue, "Expression did not evalute: " + expression); }
/// <summary> /// Finds the matching nodes of a <see cref="IOldExpression"/>. /// </summary> /// <param name="node">The agent expression to check.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="resolvedExpression">The result of the search.</param> public static bool ResolveCompilerReferences(IOldExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression) { resolvedExpression = new ResolvedExpression(); IClass EmbeddingClass = node.EmbeddingClass; IQualifiedName Query = (IQualifiedName)node.Query; IList <IIdentifier> ValidPath = Query.ValidPath.Item; IClassType BaseType = EmbeddingClass.ResolvedClassType.Item; if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Boolean.Guid, node, out ITypeName BooleanTypeName, out ICompiledType BooleanType)) { errorList.AddError(new ErrorBooleanTypeMissing(node)); return(false); } ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node); Debug.Assert(LocalScope != null); if (node.EmbeddingBody == null && node.EmbeddingAssertion == null) { errorList.AddError(new ErrorInvalidOldExpression(node)); return(false); } if (!ObjectType.GetQualifiedPathFinalType(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, errorList, out ICompiledFeature FinalFeature, out IDiscrete FinalDiscrete, out ITypeName FinalTypeName, out ICompiledType FinalType, out bool InheritBySideAttribute)) { return(false); } if (FinalFeature == null) { errorList.AddError(new ErrorInvalidOldExpression(node)); return(false); } ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Query.ValidResultTypePath.Item); resolvedExpression.ResolvedFinalFeature = FinalFeature; resolvedExpression.ResolvedResult = new ResultType(FinalTypeName, FinalType, string.Empty); resolvedExpression.ResolvedException = new ResultException(); #if COVERAGE Debug.Assert(!node.IsComplex); #endif return(true); }
public void ListEqualsIntegerNegativeAssertion() { string expression = "${MyVariable[0]==10}"; string key = "MyVariable"; int[] val = { 11 }; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.IsFalse((bool)resolved_exp.ResolvedValue); }
public void ListEqualsStringNegativeAssertion() { string expression = "${MyVariable=='asdf'}"; string key = "MyVariable"; string[] val = { "asdfsa" }; DataContext dc = new DataContext(); dc.RegisterDataItem(key, val); ResolvedExpression resolved_exp = Engine.ResolveExpression(expression, dc); Assert.IsFalse((bool)(resolved_exp.ResolvedValue)); }
/// <summary> /// 解析原始表达式(OriginExpression),生成 ResolvedExpression, /// 调用此函数之前请先调用 RegistryElements<T> 注册表达式对象 /// </summary> async System.Threading.Tasks.Task Resolve() { var elems = OriginExpression.Split(new[] { "==", "}.", "+", "-", "*", "/", "^", "(", ")", " " }, StringSplitOptions.RemoveEmptyEntries); var elements = new List <ExpressionElement>(); await System.Threading.Tasks.Task.Run(() => { foreach (var elem in elems) { //elem = elem + "}"; foreach (var expelement in ElementCollection) { var arr = elem.Split('{'); if (expelement.Type == arr[0]) { var e = expelement.Clone() as ExpressionElement; e.Original = arr[1]; e.DoProcess(); if (e.Original != e.Value.ToString() && e.Value != null) { var reg = new Regex($"{e.Type}{{{e.Original}}}"); ResolvedExpression = reg.Replace(ResolvedExpression, e.Value.ToString(), 1); } elements.Add(e); } } } // 检查表达式是否计算完成 if (ResolvedExpression.IndexOf("{") < 0) { // 生成表达式计算结果 var expression = ResolvedExpression.Replace("==", "="); DataTable table = new DataTable(); var value = table.Compute(expression, ""); if ((int)value == 1) { Result = true; } } }); }
/// <summary> /// Evaluates the current LoopConditionalExpression. /// Returns the result /// </summary> /// <returns></returns> protected bool EvaluateLoopConditionalExpressionPasses() { if (String.IsNullOrEmpty(LoopConditionalExpression)) { return(true); } ResolvedExpression resolvedExpression = Engine.ResolveExpression(LoopConditionalExpression, MyDataContext); if (resolvedExpression.HasException()) { return(false); } if (resolvedExpression.ResolvedType != ResolvedExpression.booleanType) { return(false); } return((bool)resolvedExpression.ResolvedValue); }
/* * Two precursor index expressions cannot be compared because it happens only when comparing different features, and there can be only one indexer. * public static bool IsExpressionEqual(IPrecursorIndexExpression expression1, IPrecursorIndexExpression expression2) * { * bool Result = true; * * if (expression1.AncestorType.IsAssigned && expression2.AncestorType.IsAssigned) * { * IObjectType AncestorType1 = (IObjectType)expression1.AncestorType; * IObjectType AncestorType2 = (IObjectType)expression2.AncestorType; * * Debug.Assert(AncestorType1.ResolvedType.IsAssigned); * Debug.Assert(AncestorType2.ResolvedType.IsAssigned); * * Result &= AncestorType1.ResolvedType.Item == AncestorType2.ResolvedType.Item; * } * * Result &= expression1.AncestorType.IsAssigned == expression2.AncestorType.IsAssigned; * Result &= Argument.IsArgumentListEqual(expression1.ArgumentList, expression2.ArgumentList); * * return Result; * } */ /// <summary> /// Finds the matching nodes of a <see cref="IPrecursorIndexExpression"/>. /// </summary> /// <param name="node">The agent expression to check.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="resolvedExpression">The result of the search.</param> public static bool ResolveCompilerReferences(IPrecursorIndexExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression) { resolvedExpression = new ResolvedExpression(); IOptionalReference <BaseNode.IObjectType> AncestorType = node.AncestorType; IList <IArgument> ArgumentList = node.ArgumentList; IClass EmbeddingClass = node.EmbeddingClass; ISealableDictionary <string, IImportedClass> ClassTable = EmbeddingClass.ImportedClassTable; ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = EmbeddingClass.FeatureTable; IFeature InnerFeature = node.EmbeddingFeature; if (InnerFeature is IIndexerFeature AsIndexerFeature) { IFeatureInstance Instance = FeatureTable[FeatureName.IndexerFeatureName]; if (!Instance.FindPrecursor(node.AncestorType, errorList, node, out IFeatureInstance SelectedPrecursor)) { return(false); } resolvedExpression.SelectedPrecursor = SelectedPrecursor; if (!ResolveSelectedPrecursor(node, SelectedPrecursor, errorList, ref resolvedExpression)) { return(false); } } else { errorList.AddError(new ErrorIndexPrecursorNotAllowedOutsideIndexer(node)); return(false); } #if COVERAGE Debug.Assert(!node.IsComplex); #endif return(true); }
/// <summary> /// Evaluates the current IfConditionExpression. /// Returns the result /// </summary> /// <returns></returns> protected bool EvaluateIfCondition() { if (String.IsNullOrEmpty(IfConditionExpression)) { return(false); } ResolvedExpression resolvedExpression = Engine.ResolveExpression(IfConditionExpression, MyDataContext); if (resolvedExpression.HasException()) { return(false); } if (resolvedExpression.ResolvedType != ResolvedExpression.booleanType) { return(false); } else { return((bool)resolvedExpression.ResolvedValue); } }
/// <summary> /// Finds the matching nodes of a <see cref="IQueryExpression"/>. /// </summary> /// <param name="node">The agent expression to check.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="resolvedExpression">The result of the search.</param> public static bool ResolveCompilerReferences(IQueryExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression) { resolvedExpression = new ResolvedExpression(); IQualifiedName Query = (IQualifiedName)node.Query; IList <IArgument> ArgumentList = node.ArgumentList; IClass EmbeddingClass = node.EmbeddingClass; IClassType BaseType = EmbeddingClass.ResolvedClassType.Item; IList <IIdentifier> ValidPath = Query.ValidPath.Item; ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node); if (!ObjectType.GetQualifiedPathFinalType(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, errorList, out ICompiledFeature FinalFeature, out IDiscrete FinalDiscrete, out ITypeName FinalTypeName, out ICompiledType FinalType, out bool InheritBySideAttribute)) { return(false); } Debug.Assert(FinalFeature != null || FinalDiscrete != null); #if COVERAGE Debug.Assert(!node.IsComplex); #endif if (FinalFeature != null) { resolvedExpression.ResolvedFinalFeature = FinalFeature; return(ResolveFeature(node, errorList, FinalFeature, FinalTypeName, FinalType, ref resolvedExpression)); } else { Debug.Assert(FinalDiscrete != null); resolvedExpression.ResolvedFinalDiscrete = FinalDiscrete; return(ResolveDiscrete(node, errorList, FinalDiscrete, ref resolvedExpression)); } }
private static bool ResolveCall(IPrecursorExpression node, IFeatureInstance selectedPrecursor, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; ICompiledFeature OperatorFeature = selectedPrecursor.Feature; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); bool IsHandled = false; bool Success = false; switch (OperatorFeature) { case IAttributeFeature AsAttributeFeature: case ICreationFeature AsCreationFeature: case IProcedureFeature AsProcedureFeature: case IIndexerFeature AsIndexerFeature: errorList.AddError(new ErrorInvalidExpression(node)); IsHandled = true; break; case IConstantFeature AsConstantFeature: Success = ResolveCallClass(node, selectedPrecursor, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList); IsHandled = true; break; case IFunctionFeature AsFunctionFeature: IFunctionType FunctionType = AsFunctionFeature.ResolvedAgentType.Item as IFunctionType; Debug.Assert(FunctionType != null); Success = ResolveCallFunction(node, selectedPrecursor, FunctionType, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList); IsHandled = true; break; case IPropertyFeature AsPropertyFeature: IPropertyType PropertyType = AsPropertyFeature.ResolvedAgentType.Item as IPropertyType; Debug.Assert(PropertyType != null); Success = ResolveCallProperty(node, selectedPrecursor, PropertyType, mergedArgumentList, argumentStyle, errorList, ref resolvedExpression, out selectedParameterList, out selectedResultList, out resolvedArgumentList); IsHandled = true; break; } Debug.Assert(IsHandled); return(Success); }
private static bool ResolveDiscrete(IQueryExpression node, IErrorList errorList, IDiscrete resolvedFinalDiscrete, ref ResolvedExpression resolvedExpression) { // This is enforced by the caller. bool IsNumberTypeAvailable = Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType); Debug.Assert(IsNumberTypeAvailable); resolvedExpression.ResolvedResult = new ResultType(NumberTypeName, NumberType, resolvedFinalDiscrete.ValidDiscreteName.Item.Name); resolvedExpression.ResolvedException = new ResultException(); if (resolvedFinalDiscrete.NumericValue.IsAssigned) { IExpression NumericValue = (IExpression)resolvedFinalDiscrete.NumericValue.Item; resolvedExpression.ConstantSourceList.Add(NumericValue); } else { resolvedExpression.ExpressionConstant = new DiscreteLanguageConstant(resolvedFinalDiscrete); } resolvedExpression.SelectedResultList = new SealableList <IParameter>(); resolvedExpression.FeatureCall = new FeatureCall(); return(true); }
private static bool ResolveFeatureAsFunctionType(IQueryExpression node, IErrorList errorList, ICompiledFeature resolvedFinalFeature, List <IExpressionType> mergedArgumentList, TypeArgumentStyles typeArgumentStyle, IFunctionType finalType, ref ResolvedExpression resolvedExpression) { // IScopeAttributeFeature is the case of an agent. IList <IArgument> ArgumentList = node.ArgumentList; IFunctionFeature AsFunctionFeature = resolvedFinalFeature as IFunctionFeature; IScopeAttributeFeature AsScopeAttributeFeature = resolvedFinalFeature as IScopeAttributeFeature; Debug.Assert(AsFunctionFeature != null || AsScopeAttributeFeature != null); IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); foreach (IQueryOverloadType Overload in finalType.OverloadList) { ParameterTableList.Add(Overload.ParameterTable); } int SelectedIndex; if (!Argument.ArgumentsConformToParameters(ParameterTableList, mergedArgumentList, typeArgumentStyle, errorList, node, out SelectedIndex)) { return(false); } resolvedExpression.SelectedOverloadType = finalType.OverloadList[SelectedIndex]; resolvedExpression.ResolvedResult = new ResultType(resolvedExpression.SelectedOverloadType.ResultTypeList); resolvedExpression.ResolvedException = new ResultException(resolvedExpression.SelectedOverloadType.ExceptionIdentifierList); if (AsFunctionFeature != null) { Debug.Assert(AsFunctionFeature.OverloadList.Count == finalType.OverloadList.Count); Debug.Assert(AsFunctionFeature.ResolvedAgentType.IsAssigned); Debug.Assert(AsFunctionFeature.ResolvedAgentType.Item == finalType); resolvedExpression.SelectedOverload = AsFunctionFeature.OverloadList[SelectedIndex]; resolvedExpression.SelectedResultList = resolvedExpression.SelectedOverload.ResultTable; resolvedExpression.FeatureCall = new FeatureCall(resolvedExpression.SelectedOverload.ParameterTable, resolvedExpression.SelectedOverload.ResultTable, ArgumentList, mergedArgumentList, typeArgumentStyle); } else { resolvedExpression.SelectedResultList = resolvedExpression.SelectedOverloadType.ResultTable; resolvedExpression.FeatureCall = new FeatureCall(resolvedExpression.SelectedOverloadType.ParameterTable, resolvedExpression.SelectedOverloadType.ResultTable, ArgumentList, mergedArgumentList, typeArgumentStyle); } return(true); }
private static bool ResolveFeature(IQueryExpression node, IErrorList errorList, ICompiledFeature resolvedFinalFeature, ITypeName finalTypeName, ICompiledType finalType, ref ResolvedExpression resolvedExpression) { ISealableDictionary <string, IScopeAttributeFeature> LocalScope = Scope.CurrentScope(node); IQualifiedName Query = (IQualifiedName)node.Query; IList <IArgument> ArgumentList = node.ArgumentList; IClass EmbeddingClass = node.EmbeddingClass; IClassType BaseType = EmbeddingClass.ResolvedClassType.Item; IList <IIdentifier> ValidPath = Query.ValidPath.Item; List <IExpressionType> MergedArgumentList = new List <IExpressionType>(); if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList)) { return(false); } IIdentifier LastIdentifier = ValidPath[ValidPath.Count - 1]; string ValidText = LastIdentifier.ValidText.Item; bool IsHandled = false; bool Success = true; switch (finalType) { case IFunctionType AsFunctionType: if (!ResolveFeatureAsFunctionType(node, errorList, resolvedFinalFeature, MergedArgumentList, TypeArgumentStyle, AsFunctionType, ref resolvedExpression)) { return(false); } IsHandled = true; break; case IProcedureType AsProcedureType: case IIndexerType AsIndexerType: errorList.AddError(new ErrorInvalidExpression(node)); Success = false; IsHandled = true; break; case IPropertyType AsPropertyType: resolvedExpression.ResolvedResult = new ResultType(AsPropertyType.ResolvedEntityTypeName.Item, AsPropertyType.ResolvedEntityType.Item, ValidText); resolvedExpression.ResolvedException = new ResultException(AsPropertyType.GetExceptionIdentifierList); resolvedExpression.SelectedResultList = new SealableList <IParameter>(); resolvedExpression.FeatureCall = new FeatureCall(); IsHandled = true; break; case IClassType AsClassType: case ITupleType AsTupleType: resolvedExpression.ResolvedResult = new ResultType(finalTypeName, finalType, ValidText); resolvedExpression.ResolvedException = new ResultException(); resolvedExpression.SelectedResultList = new SealableList <IParameter>(); resolvedExpression.FeatureCall = new FeatureCall(); IsHandled = true; break; case IFormalGenericType AsFormalGenericType: resolvedExpression.ResolvedResult = new ResultType(finalTypeName, AsFormalGenericType, ValidText); resolvedExpression.ResolvedException = new ResultException(); resolvedExpression.SelectedResultList = new SealableList <IParameter>(); resolvedExpression.FeatureCall = new FeatureCall(); IsHandled = true; break; } Debug.Assert(IsHandled); if (!Success) { return(false); } ObjectType.FillResultPath(EmbeddingClass, BaseType, LocalScope, ValidPath, 0, Query.ValidResultTypePath.Item); IsHandled = false; switch (resolvedFinalFeature) { case IConstantFeature AsConstantFeature: IExpression ConstantValue = (IExpression)AsConstantFeature.ConstantValue; resolvedExpression.ConstantSourceList.Add(ConstantValue); IsHandled = true; break; case IFunctionFeature AsFunctionFeature: Argument.AddConstantArguments(node, resolvedExpression.ResolvedResult, ArgumentList, resolvedExpression.ConstantSourceList, out ILanguageConstant ExpressionConstant); resolvedExpression.ExpressionConstant = ExpressionConstant; IsHandled = true; break; case IAttributeFeature AsAttributeFeature: case IPropertyFeature AsPropertyFeature: case IScopeAttributeFeature AsScopeAttributeFeature: resolvedExpression.ExpressionConstant = Expression.GetDefaultConstant(node, resolvedExpression.ResolvedResult); IsHandled = true; break; } Debug.Assert(IsHandled); return(true); }
private static bool ResolveSelectedPrecursor(IPrecursorIndexExpression node, IFeatureInstance selectedPrecursor, IErrorList errorList, ref ResolvedExpression resolvedExpression) { IList <IArgument> ArgumentList = node.ArgumentList; List <IExpressionType> MergedArgumentList = new List <IExpressionType>(); if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList)) { return(false); } IIndexerFeature OperatorFeature = selectedPrecursor.Feature as IIndexerFeature; Debug.Assert(OperatorFeature != null); IIndexerType OperatorType = OperatorFeature.ResolvedAgentType.Item as IIndexerType; Debug.Assert(OperatorType != null); IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); ParameterTableList.Add(OperatorType.ParameterTable); IList <ISealableList <IParameter> > ResultTableList = new List <ISealableList <IParameter> >(); ResultTableList.Add(new SealableList <IParameter>()); int SelectedIndex; if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, errorList, node, out SelectedIndex)) { return(false); } resolvedExpression.ResolvedResult = new ResultType(OperatorType.ResolvedEntityTypeName.Item, OperatorType.ResolvedEntityType.Item, string.Empty); resolvedExpression.ResolvedException = new ResultException(OperatorType.GetExceptionIdentifierList); resolvedExpression.FeatureCall = new FeatureCall(ParameterTableList[SelectedIndex], ResultTableList[SelectedIndex], ArgumentList, MergedArgumentList, TypeArgumentStyle); resolvedExpression.ResolvedFinalFeature = OperatorFeature; Argument.AddConstantArguments(ArgumentList, resolvedExpression.ConstantSourceList); return(true); }
/// <summary> /// Finds the matching nodes of a <see cref="IIndexQueryExpression"/>. /// </summary> /// <param name="node">The agent expression to check.</param> /// <param name="errorList">The list of errors found.</param> /// <param name="resolvedExpression">The result of the search.</param> public static bool ResolveCompilerReferences(IIndexQueryExpression node, IErrorList errorList, out ResolvedExpression resolvedExpression) { resolvedExpression = new ResolvedExpression(); IExpression IndexedExpression = (IExpression)node.IndexedExpression; IList <IArgument> ArgumentList = node.ArgumentList; IClass EmbeddingClass = node.EmbeddingClass; IResultType ResolvedIndexerResult = IndexedExpression.ResolvedResult.Item; IExpressionType PreferredIndexerResult = ResolvedIndexerResult.Preferred; ICompiledType IndexedExpressionType; if (PreferredIndexerResult == null) { errorList.AddError(new ErrorInvalidExpression(node)); return(false); } else { IndexedExpressionType = PreferredIndexerResult.ValueType; } if (IndexedExpressionType is IClassType AsClassType) { IClass IndexedBaseClass = AsClassType.BaseClass; ISealableDictionary <IFeatureName, IFeatureInstance> IndexedFeatureTable = IndexedBaseClass.FeatureTable; if (!IndexedFeatureTable.ContainsKey(FeatureName.IndexerFeatureName)) { errorList.AddError(new ErrorMissingIndexer(node)); return(false); } IFeatureInstance IndexerInstance = IndexedFeatureTable[FeatureName.IndexerFeatureName]; IIndexerFeature Indexer = (IndexerFeature)IndexerInstance.Feature; IIndexerType AsIndexerType = (IndexerType)Indexer.ResolvedAgentType.Item; List <IExpressionType> MergedArgumentList = new List <IExpressionType>(); if (!Argument.Validate(ArgumentList, MergedArgumentList, out TypeArgumentStyles TypeArgumentStyle, errorList)) { return(false); } IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); ParameterTableList.Add(AsIndexerType.ParameterTable); IList <ISealableList <IParameter> > ResultTableList = new List <ISealableList <IParameter> >(); ResultTableList.Add(new SealableList <IParameter>()); int SelectedIndex; if (!Argument.ArgumentsConformToParameters(ParameterTableList, MergedArgumentList, TypeArgumentStyle, errorList, node, out SelectedIndex)) { return(false); } resolvedExpression.ResolvedFinalFeature = Indexer; resolvedExpression.ResolvedResult = new ResultType(AsIndexerType.ResolvedEntityTypeName.Item, AsIndexerType.ResolvedEntityType.Item, string.Empty); resolvedExpression.ResolvedException = new ResultException(AsIndexerType.GetExceptionIdentifierList); resolvedExpression.FeatureCall = new FeatureCall(ParameterTableList[SelectedIndex], ResultTableList[SelectedIndex], ArgumentList, MergedArgumentList, TypeArgumentStyle); Argument.AddConstantArguments(ArgumentList, resolvedExpression.ConstantSourceList); } else { errorList.AddError(new ErrorInvalidExpression(node)); return(false); } #if COVERAGE Debug.Assert(!node.IsComplex); #endif return(true); }
private static bool ResolveCallFunction(IPrecursorExpression node, IFeatureInstance selectedPrecursor, IFunctionType callType, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; ICompiledFeature OperatorFeature = selectedPrecursor.Feature; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); foreach (IQueryOverloadType Overload in callType.OverloadList) { ParameterTableList.Add(Overload.ParameterTable); } if (!Argument.ArgumentsConformToParameters(ParameterTableList, mergedArgumentList, argumentStyle, errorList, node, out int SelectedIndex)) { return(false); } IFunctionFeature AsFunctionFeature = OperatorFeature as IFunctionFeature; Debug.Assert(AsFunctionFeature != null); Debug.Assert(AsFunctionFeature.OverloadList.Count == callType.OverloadList.Count); resolvedExpression.SelectedOverload = AsFunctionFeature.OverloadList[SelectedIndex]; resolvedExpression.SelectedOverloadType = callType.OverloadList[SelectedIndex]; resolvedExpression.ResolvedResult = new ResultType(resolvedExpression.SelectedOverloadType.ResultTypeList); resolvedExpression.ResolvedException = new ResultException(resolvedExpression.SelectedOverloadType.ExceptionIdentifierList); selectedParameterList = resolvedExpression.SelectedOverloadType.ParameterTable; selectedResultList = resolvedExpression.SelectedOverloadType.ResultTable; resolvedArgumentList = mergedArgumentList; return(true); }
private static bool ResolveCallProperty(IPrecursorExpression node, IFeatureInstance selectedPrecursor, IPropertyType callType, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; if (ArgumentList.Count > 0) { errorList.AddError(new ErrorInvalidExpression(node)); return(false); } else { ICompiledFeature OperatorFeature = selectedPrecursor.Feature; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); IPropertyFeature Property = (IPropertyFeature)OperatorFeature; string PropertyName = ((IFeatureWithName)Property).EntityName.Text; resolvedExpression.ResolvedResult = new ResultType(callType.ResolvedEntityTypeName.Item, callType.ResolvedEntityType.Item, PropertyName); resolvedExpression.ResolvedException = new ResultException(); if (Property.GetterBody.IsAssigned) { IBody GetterBody = (IBody)Property.GetterBody.Item; resolvedExpression.ResolvedException = new ResultException(GetterBody.ExceptionIdentifierList); } selectedParameterList = new SealableList <IParameter>(); selectedResultList = new SealableList <IParameter>(); resolvedArgumentList = new List <IExpressionType>(); return(true); } }
private static bool ResolveCallClass(IPrecursorExpression node, IFeatureInstance selectedPrecursor, List <IExpressionType> mergedArgumentList, TypeArgumentStyles argumentStyle, IErrorList errorList, ref ResolvedExpression resolvedExpression, out ISealableList <IParameter> selectedParameterList, out ISealableList <IParameter> selectedResultList, out List <IExpressionType> resolvedArgumentList) { selectedParameterList = null; selectedResultList = null; resolvedArgumentList = null; IList <IArgument> ArgumentList = node.ArgumentList; if (ArgumentList.Count > 0) { errorList.AddError(new ErrorInvalidExpression(node)); return(false); } else { ICompiledFeature OperatorFeature = selectedPrecursor.Feature; ITypeName OperatorTypeName = OperatorFeature.ResolvedEffectiveTypeName.Item; ICompiledType OperatorType = OperatorFeature.ResolvedEffectiveType.Item; IList <ISealableList <IParameter> > ParameterTableList = new List <ISealableList <IParameter> >(); resolvedExpression.ResolvedResult = new ResultType(OperatorTypeName, OperatorType, string.Empty); resolvedExpression.ResolvedException = new ResultException(); selectedParameterList = new SealableList <IParameter>(); selectedResultList = new SealableList <IParameter>(); resolvedArgumentList = new List <IExpressionType>(); } return(true); }