public string WrapWithUmlQualifiers(string descriptor)
{
if (Qualifiers.Contains(Qualifier.Private))
{
descriptor = "-" + descriptor;
}
else if (Qualifiers.Contains(Qualifier.Protected))
{
descriptor = "#" + descriptor;
}
else if (Qualifiers.Contains(Qualifier.Public))
{
descriptor = "+" + descriptor;
}
else
{
descriptor = "~" + descriptor;
}
if (Qualifiers.Contains(Qualifier.Abstract))
{
descriptor = "/" + descriptor + "/";
}
if (Qualifiers.Contains(Qualifier.Static))
{
descriptor = "_" + descriptor + "_";
}
return(descriptor);
}
public CppTypeVisitorResult Visit(CppLinkageCliArrayType t, Qualifiers q)
{
this.TypeBuilder.Append($"LinkageArray");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppNumericType t, Qualifiers q)
{
this.TypeBuilder.Append($"Numeric");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppDependentLinkageEntityType t, Qualifiers q)
{
this.TypeBuilder.Append($"DependentLinkageEntity");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppLinkageTemplateParameterType t, Qualifiers q)
{
this.TypeBuilder.Append($"LinkageTemplateParameter");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppDeclarationSpecifierType t, Qualifiers q)
{
this.TypeBuilder.Append($"DeclarationSpecifier");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppDeducedClassTypePlaceholder A_0, Qualifiers A_1)
{
this.TypeBuilder.Append($"DeducedClassTypePlaceholder");
this.DbgBuilder.Append(A_0.DbgDescription + " ");
this.QualifierBuilder.Append(A_1.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppElaboratedTypeReference t, Qualifiers q)
{
this.TypeBuilder.Append($"ElaboratedTypeReference");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppFunctionType t, Qualifiers q)
{
// has inner type
this.TypeBuilder.Append($"Function()");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppCliInteriorPointerType t, Qualifiers q)
{
// has inner type
this.TypeBuilder.Append($"CliInteriorPointer");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppResolvedClassType t, Qualifiers q)
{
this.TypeBuilder.Append($"ResolvedClassType");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
this.NameBuilder.Append(t.ResolveEntity.Name + " ");
return(null);
}
public CppTypeVisitorResult Visit(CppEnumType t, Qualifiers q)
{
this.TypeBuilder.Append($"Enum");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
this.NameBuilder.Append(t.Symbol.Name + " ");
return(null);
}
public bool Dispatch(IInvocationContext invocationContext, Exception exception, IQualifier[] qualifierArray)
{
var qualifiers = new Qualifiers(qualifierArray);
var context = new ExceptionHandlingContext(invocationContext, exception, qualifiers);
DispatchCauses(exception, context, qualifiers);
return(context.IsMarkedHandled == true);
}
/// <inheritdoc />
public override string ToString()
{
return(string.Format(
"{0}{1} {2}{3}{4}",
Qualifiers.ToString(false),
Type,
Name,
Qualifiers.ToString(true),
InitialValue != null ? " = " + InitialValue : string.Empty));
}
public CppTypeVisitorResult Visit(CppCliHandleType t, Qualifiers q)
{
// has inner type
this.TypeBuilder.Append($"CliHandleType");
this.DbgBuilder.Append(t.DbgDescription + " ");
this.QualifierBuilder.Append(q.ToString("g") + " ");
t.InnerType.Accept(this);
return(null);
}
public bool CanSatisfy(IEnumerable <IQualifier> qualifiers)
{
var qualifierTypes = qualifiers.Select(x => x.GetType()).ToArray();
if (qualifierTypes.Contains(typeof(AnyAttribute)))
{
return(true);
}
return(qualifierTypes.All(Qualifiers.Select(x => x.GetType()).Contains));
}
/// <summary>
/// Match this typeName to a candidate typeName. This type support wildcard matching against
/// the candidate
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public bool Match(TypeName t)
{
if (IsWildcard)
{
return(true);
}
if (Qualifiers.Count != t.Qualifiers.Count)
{
return(false);
}
if (BaseName != t.BaseName)
{
return(false);
}
if (Qualifiers.Where((qualifier, i) => !qualifier.Match(t.Qualifiers[i])).Any())
{
return(false);
}
// args must match one-for one,
// or if last arg is a wildcard it will match any number of additional args
if (Args.Count > t.Args.Count || (Args.Count == 0 && t.Args.Count > 0) ||
(Args.Count < t.Args.Count && !Args[Args.Count - 1].IsWildcard))
{
return(false);
}
if (Args.Where((arg, i) => !arg.Match(t.Args[i])).Any())
{
return(false);
}
if (IsArray != t.IsArray)
{
return(false);
}
if (!IsArray)
{
return(true);
}
if (Dimensions.Length != t.Dimensions.Length)
{
return(false);
}
return(Dimensions.Where((dimension, i) => dimension != t.Dimensions[i])
.All(dimension => dimension == -1));
}
public override void Cancel()
{
if (ObjectState == ObjectStates.Added)
{
Remove();
}
else if (ObjectState != ObjectStates.None)
{
_qualifier = OriginalValues._qualifier;
//_dataFieldValue = OriginalValues._dataFieldValue;
}
}
public FunctionType(
Node ret, NodeArray fparams,
Qualifiers cvQuals, FunctionRefQual refQual,
Node exceptionSpec
) : base(ItaniumDemangleNodeType.FunctionType, Cache.Yes, Cache.No, Cache.Yes)
{
this.ret = ret;
this.fparams = fparams;
this.cvQuals = cvQuals;
this.refQual = refQual;
this.exceptionSpec = exceptionSpec;
}
public FunctionEncoding(
Node ret, Node name,
NodeArray fparams, Node attrs,
Qualifiers cvQuals, FunctionRefQual refQual
) : base(ItaniumDemangleNodeType.FunctionEncoding, Cache.Yes, Cache.No, Cache.Yes)
{
this.ReturnType = ret;
this.Name = name;
this.Params = fparams;
this.attrs = attrs;
this.CVQuals = cvQuals;
this.RefQual = refQual;
}
public override void Cancel()
{
if (ObjectState == ObjectStates.Added)
{
((ValidationConditions)Parent).InternalRemove(this);
}
else if (ObjectState != ObjectStates.None)
{
_qualifier = OriginalValues._qualifier;
_validationType = OriginalValues._validationType;
_validationValue = OriginalValues._validationValue;
}
}
public bool OutputQualifierIfPresent(OutputStream os, Qualifiers Q, Qualifiers Mask, bool needSpace)
{
if (!(Q.HasFlag(Mask)))
{
return(needSpace);
}
if (needSpace)
{
os.Append(' ');
}
OutputSingleQualifier(os, Mask);
return(true);
}
public Pb.Filter ConvertToPBFilter()
{
var internalFilter = new Pb.FirstKeyValueMatchingQualifiersFilter();
if (Qualifiers?.Any() == true)
{
internalFilter.Qualifiers.AddRange(Qualifiers.Select(ByteString.CopyFrom).ToArray());
}
var filter = new Pb.Filter
{
Name = Name,
SerializedFilter = internalFilter.ToByteString()
};
return(filter);
}
public void OutputQualifiers(OutputStream os, Qualifiers Q, bool spaceBefore, bool spaceAfter)
{
if (Q == Qualifiers.None)
{
return;
}
int pos1 = os.Length;
spaceBefore = OutputQualifierIfPresent(os, Q, Qualifiers.Const, spaceBefore);
spaceBefore = OutputQualifierIfPresent(os, Q, Qualifiers.Volatile, spaceBefore);
spaceBefore = OutputQualifierIfPresent(os, Q, Qualifiers.Restrict, spaceBefore);
int pos2 = os.Length;
if (spaceAfter && pos2 > pos1)
{
os.Append(' ');
}
}
// Equality and comparers
/// <summary>
/// Returns the hashcode for this <see cref="InlineMergeRequest"/>.
/// </summary>
/// <returns>The hashcode value.</returns>
public override int GetHashCode()
{
// Make sure to return if it is already provided
if (!ReferenceEquals(null, m_hashCode))
{
return(m_hashCode.Value);
}
// Get first the entity hash code
var hashCode = $"InlineMerge.{EntityType.FullName}".GetHashCode();
// Gets the target fields
if (Fields != null)
{
Fields.ToList().ForEach(field =>
{
hashCode += field.GetHashCode();
});
}
// Gets the qualifier fields
if (Qualifiers != null)
{
Qualifiers.ToList().ForEach(field =>
{
hashCode += field.GetHashCode();
});
}
// Override ignore hashcode
if (OverrideIgnore != null)
{
hashCode += OverrideIgnore.GetHashCode();
}
// Set back the hash code value
m_hashCode = hashCode;
// Return the actual value
return(hashCode);
}
public bool OutputSingleQualifier(OutputStream os, Qualifiers Q)
{
switch (Q)
{
case Qualifiers.Const:
os.Append("const");
return(true);
case Qualifiers.Volatile:
os.Append("volatile");
return(true);
case Qualifiers.Restrict:
os.Append("__restrict");
return(true);
default:
break;
}
return(false);
}
void M()
{
var q = Field;
q = Property;
q = Method();
q = this.Field;
q = this.Property;
q = this.Method();
q = StaticField;
q = StaticProperty;
q = StaticMethod();
q = Qualifiers.StaticField;
q = Qualifiers.StaticProperty;
q = Qualifiers.StaticMethod();
q = Qualifiers.StaticField.Field;
q = Qualifiers.StaticProperty.Property;
q = Qualifiers.StaticMethod().Method();
}
public MethodWithQualifiers(AST Method = default, Qualifiers Qualifiers = default, @string RefQualifier = default)
{
this.Method = Method;
this.Qualifiers = Qualifiers;
this.RefQualifier = RefQualifier;
}
public string GetQualifierValue(string qualifierName)
{
return(Qualifiers.FirstOrDefault(qualifier => qualifier.QualifierName == qualifierName)?.QualifierValue);
}
public QualType(Node child, Qualifiers quals) : base(ItaniumDemangleNodeType.QualType, child.RHSComponentCache, child.ArrayCache, child.FunctionCache)
{
this.child = child;
this.quals = quals;
}
