public bool Verification(out string message)
{
message = "";
isCorrect = propertiesSystem.VerificationParametersWithEnter(TypeParameter.GetDependences(), out List <string> messages);
string postfix = string.Format("Проверьте правильность полей: {0}", string.Join(',', messages));
if (!Value.HasValue)
{
message = String.Format("Не удалось расчитать значение параметра {0}. {1}", Designation, postfix);
isCorrect = false;
}
else
{
if (Value.Value <= 0)
{
message = String.Format("Значение параметра {0} должно быть > 0. {1}", Designation, postfix);
isCorrect = false;
}
else if (StaticData.ConditionsForParameterForAnalysis.TryGetValue(this.TypeParameter, out Condition condition))
{
if (!condition.InvokeComparison(Value.Value))
{
message = String.Format("Значение параметра {0} должно быть {1}. {2}", Designation, condition.ErrorMessage, postfix);
isCorrect = false;
}
}
}
return(isCorrect);
}
/// <summary>
/// Writes the list of type parameters for a generic code element.
/// </summary>
/// <param name="genericElement">Generic code element.</param>
private void WriteTypeParameters(IGenericElement genericElement)
{
if (genericElement.TypeParameters.Count > 0)
{
Writer.Write(CSharpSymbol.BeginGeneric);
for (int parameterIndex = 0; parameterIndex < genericElement.TypeParameters.Count; parameterIndex++)
{
TypeParameter typeParameter = genericElement.TypeParameters[parameterIndex];
if (typeParameter.IsIn)
{
Writer.Write("in ");
}
else if (typeParameter.IsOut)
{
Writer.Write("out ");
}
Writer.Write(typeParameter.Name);
if (parameterIndex < genericElement.TypeParameters.Count - 1)
{
Writer.Write(CSharpSymbol.AliasSeparator);
Writer.Write(' ');
}
}
Writer.Write(CSharpSymbol.EndGeneric);
}
}
/// <summary>
/// Writes the type parameter constraints.
/// </summary>
/// <param name="typeParameter">The type parameter.</param>
private void WriteTypeParameterConstraints(TypeParameter typeParameter)
{
if (typeParameter.Constraints.Count > 0)
{
Writer.Write(' ');
Writer.Write(VBKeyword.As);
Writer.Write(' ');
if (typeParameter.Constraints.Count > 1)
{
Writer.Write(VBSymbol.BeginTypeConstraintList);
}
for (int constraintIndex = 0; constraintIndex < typeParameter.Constraints.Count;
constraintIndex++)
{
string constraint = typeParameter.Constraints[constraintIndex];
Writer.Write(constraint);
if (constraintIndex < typeParameter.Constraints.Count - 1)
{
Writer.Write(VBSymbol.AliasSeparator);
Writer.Write(' ');
}
}
if (typeParameter.Constraints.Count > 1)
{
Writer.Write(VBSymbol.EndTypeConstraintList);
}
}
}
public static ParameterBase[] GetParameters(ParsingData parser, ParameterDefineNode[] defineNodes)
{
ParameterBase[] parameters = new ParameterBase[defineNodes.Length];
for (int i = 0; i < parameters.Length; i++)
{
EnumData enumData = null;
DefinedType type = null;
if (defineNodes[i].Type != null)
{
enumData = EnumData.GetEnum(defineNodes[i].Type);
type = parser.GetDefinedType(defineNodes[i].Type, null);
if (enumData == null && type == null)
{
throw SyntaxErrorException.NonexistentType(defineNodes[i].Type, defineNodes[i].Location);
}
}
if (enumData != null)
{
parameters[i] = new EnumParameter(defineNodes[i].VariableName, enumData.Type);
}
else if (type != null)
{
parameters[i] = new TypeParameter(defineNodes[i].VariableName, type);
}
else
{
parameters[i] = new Parameter(defineNodes[i].VariableName, Elements.ValueType.Any, null);
}
}
return(parameters);
}
/// <summary>
/// Writes the type parameters.
/// </summary>
/// <param name="genericElement">The generic element.</param>
private void WriteTypeParameters(IGenericElement genericElement)
{
if (genericElement.TypeParameters.Count > 0)
{
Writer.Write(VBSymbol.BeginParameterList);
Writer.Write(VBKeyword.Of);
Writer.Write(' ');
for (int parameterIndex = 0; parameterIndex < genericElement.TypeParameters.Count; parameterIndex++)
{
TypeParameter typeParameter = genericElement.TypeParameters[parameterIndex];
Writer.Write(typeParameter.Name);
WriteTypeParameterConstraints(typeParameter);
if (parameterIndex < genericElement.TypeParameters.Count - 1)
{
Writer.Write(VBSymbol.AliasSeparator);
Writer.Write(' ');
}
}
Writer.Write(VBSymbol.EndParameterList);
}
}
public Argument(string name, string defaultValue, bool hasDefaultValue, TypeParameter type)
{
Name = name;
DefaultValue = defaultValue;
HasDefaultValue = hasDefaultValue;
Type = type;
}
/// <summary>
/// Function Declartion
/// </summary>
public FunctionDeclaration VisitFunctionDeclaration()
{
Labels.Clear();
if (TokenType == TokenType.Identifier)
{
ReadVariableName(out string name);
MoveNext();
NodeList <TypeParameter> parameterList;
//return type
TypeParameter[] parameters = new TypeParameter[0];
if (TokenType == TokenType.LeftParenthesis)
{
parameters = VisitFunctionParameters().ToArray();
}
parameterList = new NodeList <TypeParameter>(parameters);
//todo throw if other
MoveNextIf(TokenType.RightParenthesis);
TypeSyntax returnType = null;
if (TokenType == TokenType.Colon)
{
MoveNext();
returnType = VisitType();
}
//todo abstract, virtual functions
//To avoid block function
BlockStatement body = VisitBlock();
return(new FunctionDeclaration(name, parameterList, returnType, body));
}
throw new System.Exception($"Syntax error at line {Source.LineInfo}");
}
private TypeParameter getTypeParameter(string prepType, int paramId)
{
switch (prepType)
{
case "Линейная нормализация 1 (к float)":
return(TypeParameter.Real);
case "Нелинейная нормализация 2 (к float)":
return(TypeParameter.Real);
case "нормализация 3 (к int)":
return(TypeParameter.Int);
case "бинаризация":
return(TypeParameter.Int);
case "без предобработки":
models.Parameter param = ((models.Parameter)services.DatabaseManager.SharedManager.entityById(paramId, typeof(models.Parameter)));
TypeParameter type = param.Type;
return(type);
default:
return(TypeParameter.Real);
}
}
public override object VisitMethodDeclaration (ICSharpCode.NRefactory.Ast.MethodDeclaration methodDeclaration, object data)
{
DomMethod method = new DomMethod ();
method.Name = methodDeclaration.Name;
method.Documentation = RetrieveDocumentation (methodDeclaration.StartLocation.Line);
method.Location = ConvertLocation (methodDeclaration.StartLocation);
method.BodyRegion = ConvertRegion (methodDeclaration.EndLocation, methodDeclaration.Body != null ? methodDeclaration.Body.EndLocation : new ICSharpCode.NRefactory.Location (-1, -1));
method.Modifiers = ConvertModifiers (methodDeclaration.Modifier);
if (methodDeclaration.IsExtensionMethod)
method.MethodModifier |= MethodModifier.IsExtension;
method.ReturnType = ConvertReturnType (methodDeclaration.TypeReference);
AddAttributes (method, methodDeclaration.Attributes);
method.Add (ConvertParameterList (method, methodDeclaration.Parameters));
AddExplicitInterfaces (method, methodDeclaration.InterfaceImplementations);
if (methodDeclaration.Templates != null && methodDeclaration.Templates.Count > 0) {
foreach (ICSharpCode.NRefactory.Ast.TemplateDefinition template in methodDeclaration.Templates) {
TypeParameter parameter = ConvertTemplateDefinition (template);
method.AddTypeParameter (parameter);
}
}
method.DeclaringType = typeStack.Peek ();
typeStack.Peek ().Add (method);
return null;
}
public Argument(string name, string defaultValue, bool hasDefaultValue, TypeParameter type)
{
Name = name;
DefaultValue = defaultValue;
HasDefaultValue = hasDefaultValue;
Type = type;
}
public static TypeParameter ReadTypeParameter(BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
{
string name = ReadString(reader, nameTable);
TypeParameter tp = new TypeParameter(name);
// Flags
tp.TypeParameterModifier = (TypeParameterModifier)reader.ReadByte();
// Variance
tp.Variance = (TypeParameterVariance)reader.ReadByte();
// Constraints
uint count = ReadUInt(reader, 1000);
while (count-- > 0)
{
tp.AddConstraint(ReadReturnType(reader, nameTable, objectTable));
}
// Attributes
count = ReadUInt(reader, 1000);
while (count-- > 0)
{
tp.AddAttribute(ReadAttribute(reader, nameTable, objectTable));
}
return(tp);
}
protected override async Task <TypeParameter> AssignUpsertedReferences(TypeParameter record)
{
record.Identifier = await _identifiers.UpsertAsync(record.Identifier);
record.IdentifierId = record.Identifier?.IdentifierId ?? record.IdentifierId;
return(record);
}
public List <TypeParameter> ParseVariantTypeParameterList(
BufferedTokenStream tokenStream,
CSharpParser.Variant_type_parameterContext[] variantTypeParameters,
CSharpParser.Type_parameter_constraints_clauseContext[] constraintsClauses)
{
var typeParamList = new List <TypeParameter>();
var typeParamDict = new Dictionary <string, TypeParameter>();
if (variantTypeParameters != null)
{
foreach (var variantTypeParameter in variantTypeParameters)
{
var typeParam = variantTypeParameter.identifier().GetText();
var typeParameter = new TypeParameter()
{
TypeParam = typeParam,
VarianceAnnotation = variantTypeParameter?.variance_annotation()?.GetText()
};
typeParamDict.Add(typeParam, typeParameter);
typeParamList.Add(typeParameter);
}
}
if (constraintsClauses != null)
{
foreach (var constraintClause in constraintsClauses)
{
var identifier = constraintClause.identifier().GetText();
var typeParameter = typeParamDict[identifier];
var constraints = constraintClause.type_parameter_constraints();
var primaryConstraint = constraints?.primary_constraint()?.GetText();
if (primaryConstraint != null)
{
typeParameter.Constraints.Add(primaryConstraint);
}
var secondaryConstraints = constraints?.secondary_constraints()?.secondary_constraint();
if (secondaryConstraints != null)
{
foreach (var secondaryConstraint in secondaryConstraints)
{
typeParameter.Constraints.Add(secondaryConstraint.GetText());
}
}
var constructorConstraint = constraints?.constructor_constraint()?.GetText();
if (constructorConstraint != null)
{
typeParameter.Constraints.Add(constructorConstraint);
}
}
}
return(typeParamList);
}
public ArchiveParameter(models.Parameter par)
{
this.ID = par.ID;
this.Name = par.Name;
this.Index = par.Index;
this.Type = par.Type;
this.Comment = par.Comment;
this.IsOutput = par.IsOutput;
}
public Parameter(archive.ArchiveParameter par)
{
this.nameTable = "Parameter";
this.Name = par.Name;
this.Index = par.Index;
this.Type = par.Type;
this.Comment = par.Comment;
this.IsOutput = par.IsOutput;
}
/// <summary>
/// Appends the specified parameter to the list of type parameters.
///
/// <param name="p">a type parameter</param>
/// </summary>
public void add_type_parameter(TypeParameter p)
{
if (type_parameters == null)
{
type_parameters = new List <TypeParameter>();
}
type_parameters.Add(p);
scope.add(p.name, p);
}
private TypeParamNode ToTypeParamNode(TypeParameter tp, DocComment dc)
{
Console.WriteLine("Type parameter: " + tp.Name);
return(new TypeParamNode {
Name = tp.Name,
UserDoc = dc == null || dc.TypeParamTags == null ? null : dc.TypeParamTags[tp.Name],
Token = ToTokenNode(tp.tok),
});
}
public List <TypeParameter> GetTypeParameterList()
{
var typeParameter = new TypeParameter(GetSymbolAtom(), PrimitiveType.NumberType, DefaultLineInfo);
var typeParameter2 = new TypeParameter(GetSymbolAtom(), PrimitiveType.StringType, DefaultLineInfo);
return(new List <TypeParameter> {
typeParameter, typeParameter2
});
}
private void btn_Enter_Click(object sender, EventArgs e)
{
DateTime newtime = t_NewTime.Value;
int partition = GetSelectedPartition();
if (_mCardInfo != null)
{
_mCardInfo.CardTime = newtime;
_mCardInfo.CardPartition = partition;
TypeParameter typeparameter = new TypeParameter()
{
Lock = _mCardInfo.CardLock,
Distance = _mCardInfo.CardDistance
};
FunctionByteParameter functionbyteparameter = new FunctionByteParameter()
{
Loss = _mCardInfo.CardReportLoss,
Synchronous = _mCardInfo.Synchronous,
RegistrationType = (CardType)_mCardInfo.CardType,
ViceCardCount = _mCardInfo.ViceCardCount,
ParkingRestrictions = _mCardInfo.ParkingRestrictions,
InOutState = _mCardInfo.InOutState
};
DistanceParameterContent distancecontent = new DistanceParameterContent()
{
CardNumber = _mCardInfo.CardNumber,
Type = typeparameter,
Function = functionbyteparameter,
Count = ++_mCardInfo.CardCount
};
SingleCardData singlecarddata = new SingleCardData()
{
Time = _mCardInfo.CardTime,
Partition = _mCardInfo.CardPartition
};
byte[] by = DataCombination.CombinationDistanceCard(distancecontent, singlecarddata);
if (_mPort.IsOpen)
{
_mPort.Write(by);
}
}
else
{
DelayParamValue param = new DelayParamValue()
{
DelayTime = newtime,
Partition = partition
};
this.Tag = param;
Close();
}
}
public override DataType infer_type_argument(TypeParameter type_param, DataType value_type)
{
var array_type = value_type as ArrayType;
if (array_type != null)
{
return(element_type.infer_type_argument(type_param, array_type.element_type));
}
return(null);
}
public void CreateTest()
{
TypeParameter typeParameter = new TypeParameter();
//
// Verify default values.
//
Assert.AreEqual(string.Empty, typeParameter.Name, "Unexpected default value for name.");
Assert.IsNotNull(typeParameter.Constraints, "Constraints collection should be instantiated.");
Assert.AreEqual(0, typeParameter.Constraints.Count, "Constraints collection should be empty.");
}
public override DataType infer_type_argument(TypeParameter type_param, DataType value_type)
{
if (type_parameter == type_param)
{
var ret = value_type.copy();
ret.value_owned = true;
return(ret);
}
return(null);
}
public override DataType infer_type_argument(TypeParameter type_param, DataType value_type)
{
var pointer_type = value_type as PointerType;
if (pointer_type != null)
{
return(base_type.infer_type_argument(type_param, pointer_type.base_type));
}
return(null);
}
public List <List <Object> > getListValues(int selectionId)
{
Selection selection = ((Selection)dms.services.DatabaseManager.SharedManager.entityById(selectionId, typeof(Selection)));
int taskTemplateId = selection.ID;
List <Entity> parameters = dms.models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", taskTemplateId.ToString()), typeof(dms.models.Parameter));
List <Entity> selectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select)
.addCondition("SelectionID", "=", selectionId.ToString()), typeof(SelectionRow));
List <List <Object> > values = new List <List <Object> >();
int stepRow = 0;
foreach (Entity selRow in selectionRows)
{
int selectionRowId = selRow.ID;
int stepParam = 0;
foreach (Entity param in parameters)
{
TypeParameter type = ((dms.models.Parameter)param).Type;
int paramId = param.ID;
List <Entity> value = ValueParameter.where (new Query("ValueParameter").addTypeQuery(TypeQuery.select)
.addCondition("ParameterID", "=", paramId.ToString()).
addCondition("SelectionRowID", "=", selectionRowId.ToString()), typeof(ValueParameter));
switch (type)
{
case TypeParameter.Real:
values[stepRow][stepParam] = Convert.ToDouble((((ValueParameter)value[0]).Value).Replace(".", ","));
break;
case TypeParameter.Int:
values[stepRow][stepParam] = Convert.ToInt32(((ValueParameter)value[0]).Value);
break;
case TypeParameter.Enum:
values[stepRow][stepParam] = ((ValueParameter)value[0]).Value;
break;
default:
break;
}
stepParam++;
}
stepRow++;
}
return(values);
}
TypeParameter ConvertTemplateDefinition (ICSharpCode.NRefactory.Ast.TemplateDefinition template)
{
TypeParameter parameter = new TypeParameter (template.Name);
foreach (ICSharpCode.NRefactory.Ast.TypeReference typeRef in template.Bases) {
if (typeRef.Type == "constraint: struct")
parameter.ValueTypeRequired = true; else if (typeRef.Type == "constraint: class")
parameter.ClassRequired = true; else if (typeRef.Type == "constraint: new")
parameter.ConstructorRequired = true; else {
DomReturnType rt = ConvertReturnType (typeRef);
parameter.AddConstraint (rt);
}
}
return parameter;
}
internal static KotlinTypeParameter FromProtobuf(TypeParameter vp, JvmNameResolver resolver)
{
if (vp is null)
{
return(null);
}
return(new KotlinTypeParameter {
Id = vp.Id,
Name = resolver.GetString(vp.Name),
Reified = vp.Reified,
Variance = (KotlinVariance)vp.variance,
UpperBounds = vp.UpperBounds?.Select(ub => KotlinType.FromProtobuf(ub, resolver)).ToList(),
UpperBoundsIds = vp.UpperBoundIds
});
}
internal virtual TypeParameter[] TypeParameters()
{
if (TypeParametersConflict == null)
{
return(TypeParameter.NoParameters);
}
else
{
TypeParameter[] result = new TypeParameter[TypeParametersConflict.size()];
int i = 0;
foreach (KeyValuePair <string, TypeReference.Bound> entry in TypeParametersConflict.entrySet())
{
result[i++] = new TypeParameter(entry.Key, entry.Value);
}
return(result);
}
}
public void CloneTest()
{
TypeParameter typeParameter = new TypeParameter();
typeParameter.Name = "T";
typeParameter.AddConstraint("IDisposable");
typeParameter.AddConstraint("new()");
TypeParameter clone = typeParameter.Clone() as TypeParameter;
Assert.IsNotNull(clone, "Clone should return a TypeParameter instance.");
Assert.AreEqual(typeParameter.Name, clone.Name, "Name property was not copied correctly.");
Assert.AreEqual(typeParameter.Constraints.Count, clone.Constraints.Count, "Constraints property was not copied correctly.");
Assert.AreEqual(typeParameter.Constraints[0], clone.Constraints[0], "Constraints property was not copied correctly.");
Assert.AreEqual(typeParameter.Constraints[1], clone.Constraints[1], "Constraints property was not copied correctly.");
}
public static TypeParameter ReadTypeParameter(BinaryReader reader, INameDecoder nameTable)
{
string name = ReadString(reader, nameTable);
TypeParameter tp = new TypeParameter(name);
// Flags
byte f = reader.ReadByte();
if ((f & 1) != 0)
{
tp.ClassRequired = true;
}
if ((f & 2) != 0)
{
tp.ValueTypeRequired = true;
}
if ((f & 4) != 0)
{
tp.ConstructorRequired = true;
}
// Variance
tp.Variance = (TypeParameterVariance)reader.ReadByte();
// Constraints
uint count = ReadUInt(reader, 1000);
while (count-- > 0)
{
tp.AddConstraint(ReadReturnType(reader, nameTable));
}
// Attributes
count = ReadUInt(reader, 1000);
while (count-- > 0)
{
tp.AddAttribute(ReadAttribute(reader, nameTable));
}
return(tp);
}
/// <summary>
/// Search for the type parameter in this formal type and match it in
/// value_type.
/// </summary>
public virtual DataType infer_type_argument(TypeParameter type_param, DataType value_type)
{
var value_type_arg_it = value_type.get_type_arguments().GetEnumerator();
foreach (var formal_type_arg in this.get_type_arguments())
{
if (value_type_arg_it.MoveNext())
{
var inferred_type = formal_type_arg.infer_type_argument(type_param, value_type_arg_it.Current);
if (inferred_type != null)
{
return(inferred_type);
}
}
}
return(null);
}
public ConstructorDeclaration VisitConstructorDeclaration()
{
if (TokenType == TokenType.LeftParenthesis)
{
NodeList <TypeParameter> parameterList;
//return type
TypeParameter[] parameters = new TypeParameter[0];
if (TokenType == TokenType.LeftParenthesis)
{
parameters = VisitFunctionParameters().ToArray();
}
parameterList = new NodeList <TypeParameter>(parameters);
//todo throw if other
MoveNextIf(TokenType.RightParenthesis);
//todo abstract, virtual functions
//To avoid block function
BlockStatement body = VisitBlock();
return(new ConstructorDeclaration(parameterList, body));
}
throw new System.Exception("Syntax error at " + Source.LineInfo);
}
void case_388()
#line 3218 "cs-parser.jay"
{
if (GetTokenName (yyToken) == "type")
report.Error (81, GetLocation (yyVals[0+yyTop]), "Type parameter declaration must be an identifier not a type");
else
Error_SyntaxError (yyToken);
yyVal = new TypeParameter (MemberName.Null, null, null);
}
public override IType CreateInstantiatedParameterType (ITypeParameterMember typeParameterMember, TypeParameter tp)
{
return decorated.CreateInstantiatedParameterType (typeParameterMember, tp);
}
void case_379()
#line 3532 "ps-parser.jay"
{
var lt = (Tokenizer.LocatedToken)yyVals[0+yyTop];
yyVal = new TypeParameter (new MemberName (lt.Value, lt.Location), (Attributes)yyVals[-2+yyTop], (Variance) yyVals[-1+yyTop]);
}
void case_387()
#line 3210 "cs-parser.jay"
{
var lt = (LocatedToken)yyVals[0+yyTop];
var variance = (VarianceDecl) yyVals[-1+yyTop];
yyVal = new TypeParameter (new MemberName (lt.Value, lt.Location), (Attributes)yyVals[-2+yyTop], variance);
if (variance != null)
lbag.AddLocation (yyVal, savedLocation);
}
void case_362()
#line 2978 "cs-parser.jay"
{
var lt = (Tokenizer.LocatedToken)yyVals[0+yyTop];
var variance = (Variance) yyVals[-1+yyTop];
yyVal = new TypeParameter (new MemberName (lt.Value, lt.Location), (Attributes)yyVals[-2+yyTop], variance);
if (variance != Variance.None)
lbag.AddLocation (yyVal, savedLocation);
}
public void VisitParameter(TypeParameter t)
{
}
public TypeParameter CloneTypeParam(TypeParameter tp) {
return new TypeParameter(Tok(tp.tok), tp.Name, tp.EqualitySupport, tp);
}
public DynamicSiteClass (TypeContainer parent, MemberBase host, TypeParameter[] tparams)
: base (parent, MakeMemberName (host, "DynamicSite", parent.DynamicSitesCounter, tparams, Location.Null), tparams, Modifiers.STATIC)
{
parent.DynamicSitesCounter++;
}
public DynamicSiteClass(TypeContainer parent, MemberBase host, TypeParameter[] tparams)
: base(parent, MakeMemberName (host, "DynamicSite", parent.DynamicSitesCounter, tparams, Location.Null), tparams, Modifiers.STATIC)
{
if (tparams != null) {
mutator = new TypeParameterMutator (tparams, CurrentTypeParameters);
}
parent.DynamicSitesCounter++;
}
public virtual IType CreateInstantiatedParameterType (ITypeParameterMember typeParameterMember, TypeParameter tp)
{
return new InstantiatedParameterType (this, typeParameterMember, tp);
}
public static TypeParameter ReadTypeParameter (BinaryReader reader, INameDecoder nameTable)
{
string name = ReadString (reader, nameTable);
TypeParameter tp = new TypeParameter (name);
// Flags
byte f = reader.ReadByte ();
if ((f & 1) != 0)
tp.ClassRequired = true;
if ((f & 2) != 0)
tp.ValueTypeRequired = true;
if ((f & 4) != 0)
tp.ConstructorRequired = true;
// Variance
tp.Variance = (TypeParameterVariance)reader.ReadByte ();
// Constraints
uint count = ReadUInt (reader, 1000);
while (count-- > 0)
tp.AddConstraint (ReadReturnType (reader, nameTable));
// Attributes
count = ReadUInt (reader, 1000);
while (count-- > 0)
tp.AddAttribute (ReadAttribute (reader, nameTable));
return tp;
}
/// <summary>
/// Default Constructor
/// </summary>
public Comparison()
{
Parameter = TypeParameter.GetCurrentHeal;
Operator = TypeOperator.LowerEqual;
Value = 100;
}
private TypeNode ParseTypeSignature(MemoryCursor/*!*/ sigReader, ref bool pinned, ref bool isTypeArgument)
{
TypeNode elementType;
ElementType tok = (ElementType)sigReader.ReadCompressedInt();
if (tok == ElementType.Pinned)
{
pinned = true;
tok = (ElementType)sigReader.ReadCompressedInt();
}
switch (tok)
{
case ElementType.Boolean: return CoreSystemTypes.Boolean;
case ElementType.Char: return CoreSystemTypes.Char;
case ElementType.Double: return CoreSystemTypes.Double;
case ElementType.Int16: return CoreSystemTypes.Int16;
case ElementType.Int32: return CoreSystemTypes.Int32;
case ElementType.Int64: return CoreSystemTypes.Int64;
case ElementType.Int8: return CoreSystemTypes.Int8;
case ElementType.IntPtr: return CoreSystemTypes.IntPtr;
case ElementType.BoxedEnum:
case ElementType.Object: return CoreSystemTypes.Object;
case ElementType.Single: return CoreSystemTypes.Single;
case ElementType.String: return CoreSystemTypes.String;
case ElementType.DynamicallyTypedReference: return CoreSystemTypes.DynamicallyTypedReference;
case ElementType.UInt16: return CoreSystemTypes.UInt16;
case ElementType.UInt32: return CoreSystemTypes.UInt32;
case ElementType.UInt64: return CoreSystemTypes.UInt64;
case ElementType.UInt8: return CoreSystemTypes.UInt8;
case ElementType.UIntPtr: return CoreSystemTypes.UIntPtr;
case ElementType.Void: return CoreSystemTypes.Void;
case ElementType.Pointer:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
if (elementType == null) return null;
return elementType.GetPointerType();
case ElementType.Reference:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
return elementType.GetReferenceType();
case ElementType.FunctionPointer:
return this.ParseFunctionPointer(sigReader);
case ElementType.OptionalModifier:
case ElementType.RequiredModifier:
TypeNode modifier = this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt());
if (modifier == null) modifier = CoreSystemTypes.Object;
TypeNode modified = this.ParseTypeSignature(sigReader, ref pinned);
if (modified == null) modified = CoreSystemTypes.Object;
if (modified == null || modified == null) return null;
if (tok == ElementType.RequiredModifier)
return RequiredModifier.For(modifier, modified);
else
return OptionalModifier.For(modifier, modified);
case ElementType.Class:
return this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt());
case ElementType.ValueType:
return this.DecodeAndGetTypeDefOrRefOrSpec(sigReader.ReadCompressedInt(), true);
case ElementType.TypeParameter:
TypeNode tPar = null;
int pnum = sigReader.ReadCompressedInt();
if (this.currentTypeParameters != null && this.currentTypeParameters.Count > pnum)
tPar = this.currentTypeParameters[pnum];
if (tPar == null)
{
HandleError(this.module, String.Format(CultureInfo.CurrentCulture,
ExceptionStrings.BadTypeParameterInPositionForType, pnum, this.currentType == null ? "" : this.currentType.FullName));
tPar = new TypeParameter();
tPar.Name = Identifier.For("Bad type parameter in position " + pnum);
tPar.DeclaringModule = this.module;
}
isTypeArgument = true;
return tPar;
case ElementType.MethodParameter:
TypeNode mTPar = null;
pnum = sigReader.ReadCompressedInt();
if (this.currentMethodTypeParameters != null && this.currentMethodTypeParameters.Count > pnum)
mTPar = this.currentMethodTypeParameters[pnum];
if (mTPar == null)
{
HandleError(this.module, String.Format(CultureInfo.CurrentCulture,
ExceptionStrings.BadMethodTypeParameterInPosition, pnum));
mTPar = new MethodTypeParameter();
mTPar.Name = Identifier.For("Bad method type parameter in position " + pnum);
}
isTypeArgument = true;
return mTPar;
case ElementType.GenericTypeInstance:
TypeNodeList savedCurrentTypeParameters = this.currentTypeParameters;
TypeNode template = this.ParseTypeSignature(sigReader, ref pinned);
this.currentTypeParameters = savedCurrentTypeParameters;
if (template == null || template.ConsolidatedTemplateParameters == null) return template; //Likely a dummy type
if (CoreSystemTypes.Initialized)
{
if (this.currentTypeParameters == null || this.currentTypeParameters.Count == 0)
this.currentTypeParameters = template.ConsolidatedTemplateParameters;
TypeNodeList genArgs = this.ParseTypeList(sigReader);
if (this.module == null) return null;
TypeNode genInst = template.GetGenericTemplateInstance(this.module, genArgs);
this.currentTypeParameters = savedCurrentTypeParameters;
return genInst;
}
InterfaceExpression ifaceExpr = new InterfaceExpression(null);
ifaceExpr.Template = template;
ifaceExpr.Namespace = template.Namespace;
ifaceExpr.Name = template.Name;
ifaceExpr.TemplateArguments = this.ParseTypeList(sigReader);
this.currentTypeParameters = savedCurrentTypeParameters;
return ifaceExpr;
case ElementType.SzArray:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
if (elementType == null) return null;
return elementType.GetArrayType(1);
case ElementType.Array:
elementType = this.ParseTypeSignature(sigReader, ref pinned);
if (elementType == null) elementType = CoreSystemTypes.Object;
if (elementType == null) return null;
int rank = sigReader.ReadCompressedInt();
int numSizes = sigReader.ReadCompressedInt();
int[] sizes = new int[numSizes];
for (int i = 0; i < numSizes; i++) sizes[i] = sigReader.ReadCompressedInt();
int numLoBounds = sigReader.ReadCompressedInt();
int[] loBounds = new int[numLoBounds];
for (int i = 0; i < numLoBounds; i++) loBounds[i] = sigReader.ReadCompressedInt();
return elementType.GetArrayType(rank, numSizes, numLoBounds, sizes, loBounds);
case ElementType.Sentinel: return null;
case ElementType.Type: return CoreSystemTypes.Type;
case ElementType.Enum: return this.GetTypeFromSerializedName(ReadSerString(sigReader));
}
throw new InvalidMetadataException(ExceptionStrings.MalformedSignature);
}
private TypeNode/*!*/ ConstructCorrectTypeNodeSubclass(int i, Identifier/*!*/ namesp, int firstInterfaceIndex, int lastInterfaceIndex,
TypeFlags flags, InterfaceList interfaces, int baseTypeCodedIndex, bool isSystemEnum)
{
TypeNode result;
TypeNode.TypeAttributeProvider attributeProvider = new TypeNode.TypeAttributeProvider(this.GetTypeAttributes);
TypeNode.NestedTypeProvider nestedTypeProvider = new TypeNode.NestedTypeProvider(this.GetNestedTypes);
TypeNode.TypeMemberProvider memberProvider = new TypeNode.TypeMemberProvider(this.GetTypeMembers);
bool isTemplateParameter = false;
if ((flags & TypeFlags.Interface) != 0)
{
if (isTemplateParameter)
result = new TypeParameter(interfaces, nestedTypeProvider, attributeProvider, memberProvider, i);
else
result = new Interface(interfaces, nestedTypeProvider, attributeProvider, memberProvider, i);
}
else if (isTemplateParameter)
{
result = new ClassParameter(nestedTypeProvider, attributeProvider, memberProvider, i);
}
else
{
result = null;
TypeNode baseClass = this.GetTypeIfNotGenericInstance(baseTypeCodedIndex);
if (baseClass != null)
{
if (baseClass == CoreSystemTypes.MulticastDelegate) //TODO: handle single cast delegates
result = new DelegateNode(nestedTypeProvider, attributeProvider, memberProvider, i);
else if (baseClass == CoreSystemTypes.Enum)
result = new EnumNode(nestedTypeProvider, attributeProvider, memberProvider, i);
else if (baseClass == CoreSystemTypes.ValueType &&
!(isSystemEnum && (flags & TypeFlags.Sealed) == 0))
{
result = new Struct(nestedTypeProvider, attributeProvider, memberProvider, i);
}
}
if(result == null)
result = new Class(nestedTypeProvider, attributeProvider, memberProvider, i);
}
result.Flags = flags;
result.Interfaces = interfaces;
return result;
}
private TypeNodeList/*!*/ ParseTypeList(MemoryCursor/*!*/ sigReader)
{
int n = sigReader.ReadCompressedInt();
TypeNodeList result = new TypeNodeList();
for(int i = 0; i < n; i++)
{
TypeNode t = this.ParseTypeSignature(sigReader);
if(t == null || t == Struct.Dummy)
{
// Can happen when dealing with a primitive type that implements an interface that references the primitive type.
// For example, System.String implements IComparable<System.String>.
if(this.currentType != null && !CoreSystemTypes.Initialized)
t = this.currentType;
else
{
Debug.Assert(false);
t = new TypeParameter();
t.Name = Identifier.For("Bad type parameter in position " + i);
t.DeclaringModule = this.module;
}
}
result.Add(t);
}
return result;
}
AstType ConvertToType (TypeParameter spec)
{
AstType result;
result = new SimpleType () { IdentifierToken = Identifier.Create (spec.Name, Convert (spec.Location)) };
return result;
}
string EqualitySupportSuffix(TypeParameter.EqualitySupportValue es) {
if (es == TypeParameter.EqualitySupportValue.Required ||
(es == TypeParameter.EqualitySupportValue.InferredRequired && DafnyOptions.O.DafnyPrintResolvedFile != null)) {
return "(==)";
} else {
return "";
}
}
//
// Creates a proxy base method call inside this container for hoisted base member calls
//
public MethodSpec CreateHoistedBaseCallProxy (ResolveContext rc, MethodSpec method)
{
Method proxy_method;
//
// One proxy per base method is enough
//
if (hoisted_base_call_proxies == null) {
hoisted_base_call_proxies = new Dictionary<MethodSpec, Method> ();
proxy_method = null;
} else {
hoisted_base_call_proxies.TryGetValue (method, out proxy_method);
}
if (proxy_method == null) {
string name = CompilerGeneratedContainer.MakeName (method.Name, null, "BaseCallProxy", hoisted_base_call_proxies.Count);
MemberName member_name;
TypeArguments targs = null;
TypeSpec return_type = method.ReturnType;
var local_param_types = method.Parameters.Types;
if (method.IsGeneric) {
//
// Copy all base generic method type parameters info
//
var hoisted_tparams = method.GenericDefinition.TypeParameters;
var tparams = new TypeParameters ();
targs = new TypeArguments ();
targs.Arguments = new TypeSpec[hoisted_tparams.Length];
for (int i = 0; i < hoisted_tparams.Length; ++i) {
var tp = hoisted_tparams[i];
var local_tp = new TypeParameter (tp, null, new MemberName (tp.Name, Location), null);
tparams.Add (local_tp);
targs.Add (new SimpleName (tp.Name, Location));
targs.Arguments[i] = local_tp.Type;
}
member_name = new MemberName (name, tparams, Location);
//
// Mutate any method type parameters from original
// to newly created hoisted version
//
var mutator = new TypeParameterMutator (hoisted_tparams, tparams);
return_type = mutator.Mutate (return_type);
local_param_types = mutator.Mutate (local_param_types);
} else {
member_name = new MemberName (name);
}
var base_parameters = new Parameter[method.Parameters.Count];
for (int i = 0; i < base_parameters.Length; ++i) {
var base_param = method.Parameters.FixedParameters[i];
base_parameters[i] = new Parameter (new TypeExpression (local_param_types [i], Location),
base_param.Name, base_param.ModFlags, null, Location);
base_parameters[i].Resolve (this, i);
}
var cloned_params = ParametersCompiled.CreateFullyResolved (base_parameters, method.Parameters.Types);
if (method.Parameters.HasArglist) {
cloned_params.FixedParameters[0] = new Parameter (null, "__arglist", Parameter.Modifier.NONE, null, Location);
cloned_params.Types[0] = Module.PredefinedTypes.RuntimeArgumentHandle.Resolve ();
}
// Compiler generated proxy
proxy_method = new Method (this, new TypeExpression (return_type, Location),
Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN,
member_name, cloned_params, null);
var block = new ToplevelBlock (Compiler, proxy_method.ParameterInfo, Location) {
IsCompilerGenerated = true
};
var mg = MethodGroupExpr.CreatePredefined (method, method.DeclaringType, Location);
mg.InstanceExpression = new BaseThis (method.DeclaringType, Location);
if (targs != null)
mg.SetTypeArguments (rc, targs);
// Get all the method parameters and pass them as arguments
var real_base_call = new Invocation (mg, block.GetAllParametersArguments ());
Statement statement;
if (method.ReturnType.Kind == MemberKind.Void)
statement = new StatementExpression (real_base_call);
else
statement = new Return (real_base_call, Location);
block.AddStatement (statement);
proxy_method.Block = block;
members.Add (proxy_method);
proxy_method.Define ();
proxy_method.PrepareEmit ();
hoisted_base_call_proxies.Add (method, proxy_method);
}
return proxy_method.Spec;
}
public static TypeParameter ReadTypeParameter (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable)
{
string name = ReadString (reader, nameTable);
TypeParameter tp = new TypeParameter (name);
// Flags
tp.TypeParameterModifier = (TypeParameterModifier)reader.ReadByte ();
// Variance
tp.Variance = (TypeParameterVariance)reader.ReadByte ();
// Constraints
uint count = ReadUInt (reader, 1000);
while (count-- > 0)
tp.AddConstraint (ReadReturnType (reader, nameTable, objectTable));
// Attributes
count = ReadUInt (reader, 1000);
while (count-- > 0)
tp.AddAttribute (ReadAttribute (reader, nameTable, objectTable));
return tp;
}
