public override string ToString()
{
var stringBuilder = new StringBuilder();
foreach (var attribute in Attributes)
{
stringBuilder.AppendLine(attribute.ToString());
}
stringBuilder.AppendLine(string.Format("{0} enum {1} : {2}",
AccessModifiers.ToTokenString(), Value.Name,
BaseType.ToString().ToLowerInvariant()).Trim());
stringBuilder.AppendLine("{");
var isFlags = Attributes.Any(x => x.AttributeType == typeof(FlagsAttribute));
var value = isFlags ? 1 : 0;
foreach (var item in ValueNames)
{
if (item.HasDescription)
{
stringBuilder.AppendSummary(item.Description);
}
stringBuilder.AppendLine(string.Format("{0} = {1},", GuerillaCs.ToTypeName(item.Name), value));
value = isFlags ? value << 1 : ++value;
}
stringBuilder.AppendLine("};");
return(stringBuilder.ToString().Trim());
}
public static string Generate(this AccessModifiers accessModifier)
{
if (accessModifier == AccessModifiers.Public)
{
return("public");
}
if (accessModifier == AccessModifiers.Internal)
{
return("internal");
}
if (accessModifier == AccessModifiers.Private)
{
return("private");
}
if (accessModifier == AccessModifiers.Protected)
{
return("protected");
}
if (accessModifier == AccessModifiers.Omit)
{
return("");
}
throw new NotSupportedException("Unknown access modifier specified");
}
public static string Modifiers(AccessModifiers access)
{
switch (access)
{
case AccessModifiers.Public:
return("public");
case AccessModifiers.ProtectedInternal:
return("protected internal");
case AccessModifiers.Protected:
return("protected");
case AccessModifiers.Internal:
return("internal");
case AccessModifiers.PrivateProtected:
return("private protected");
case AccessModifiers.Private:
return("private");
default: return(string.Empty);
}
}
protected override string GetFullName()
{
string result = "";
AccessModifier = AccessModifiers.GetAccessModifiers(propertyInfo.PropertyType);
result += AccessModifier;
DataAttribute = DataAttributes.GetDataAttributes(propertyInfo.PropertyType);
result += DataAttribute;
result += TypeName.GetTypeName(propertyInfo.PropertyType);
result += propertyInfo.Name + "{ ";
if (propertyInfo.CanRead)
{
getAccessModifier = AccessModifiers.GetAccessModifiers(propertyInfo.GetMethod);
result += getAccessModifier + "get; ";
}
if (propertyInfo.CanWrite)
{
setAccessModifier = AccessModifiers.GetAccessModifiers(propertyInfo.SetMethod);
result += setAccessModifier + "set; ";
}
result += " }";
return(result);
}
public static AccessModifiers DetermineAccessModifier(this SyntaxTokenList tokenList,
AccessModifiers defaultValue)
{
if (tokenList.HasModifier(SyntaxKind.ProtectedKeyword))
{
if (tokenList.HasModifier(SyntaxKind.InternalKeyword))
{
return(AccessModifiers.ProtectedInternal);
}
if (tokenList.HasModifier(SyntaxKind.PrivateKeyword))
{
return(AccessModifiers.ProtectedPrivate);
}
return(AccessModifiers.Protected);
}
if (tokenList.HasModifier(SyntaxKind.InternalKeyword))
{
return(AccessModifiers.Internal);
}
if (tokenList.HasModifier(SyntaxKind.PrivateKeyword))
{
return(AccessModifiers.Private);
}
if (tokenList.HasModifier(SyntaxKind.PublicKeyword))
{
return(AccessModifiers.Public);
}
return(defaultValue);
}
public ILConstructorBuilder DefineConstructor(AccessModifiers modifier)
{
if (this._isBuild)
{
throw new DefinitionException("Tip daha önce derlenmiş. Derlenmiş tipler üzerinde yeni üye eklemesi yapılamaz.");
}
ILConstructorBuilder builder;
switch (modifier)
{
case AccessModifiers.Public:
builder = new ILConstructorBuilder(this, MethodAttributes.Public);
break;
case AccessModifiers.Protected:
builder = new ILConstructorBuilder(this, MethodAttributes.Family);
break;
case AccessModifiers.ProtectedInternal:
builder = new ILConstructorBuilder(this, MethodAttributes.FamORAssem);
break;
case AccessModifiers.Internal:
builder = new ILConstructorBuilder(this, MethodAttributes.Assembly);
break;
default: //Private
builder = new ILConstructorBuilder(this, MethodAttributes.Private);
break;
}
this._ctors.Add(builder);
return(builder);
}
public static string GetString(this AccessModifiers accessModifier)
{
switch (accessModifier)
{
case AccessModifiers.Public:
{
return(AccessModifierNames.Public);
}
case AccessModifiers.Internal:
{
return(AccessModifierNames.Internal);
}
case AccessModifiers.Protected:
{
return(AccessModifierNames.Protected);
}
case AccessModifiers.ProtectedInternal:
{
return(AccessModifierNames.ProtectedInternal);
}
case AccessModifiers.Private:
{
return(AccessModifierNames.Private);
}
default:
{
throw new ArgumentOutOfRangeException(nameof(accessModifier), accessModifier, null);
}
}
}
public static string Get(this AccessModifiers access)
{
switch (access)
{
case AccessModifiers.None:
return("");
case AccessModifiers.Private:
return("private");
case AccessModifiers.Protected:
return("protected");
case AccessModifiers.Internal:
return("internal");
case AccessModifiers.Public:
return("public");
case AccessModifiers.ProtectedInternal:
return("protected internal");
case AccessModifiers.PrivateProtected:
return("private protected");
}
return("");
}
protected override string GetFullName()
{
string result = "";
AccessModifier = AccessModifiers.GetAccessModifiers(methodInfo);
result += AccessModifier;
DataAttribute = DataAttributes.GetDataAttributes(methodInfo);
result += DataAttribute;
result += TypeName.GetTypeName(methodInfo.ReturnType);
result += methodInfo.Name;
result += "( ";
ParameterInfo[] parametrs = methodInfo.GetParameters();
if (parametrs.Length != 0)
{
for (int i = 0; i < parametrs.Length; i++)
{
if (i != 0)
{
result += ", ";
}
paramsType.Add(TypeName.GetTypeName(parametrs[i].ParameterType));
result += paramsType[i] + parametrs[i].Name;
}
}
result += " )";
return(result);
}
private void GeneratePropertyBag(PropertyTypeNode c, List <string> propertyNames, Scope scope)
{
var gen = scope.Code;
gen.Append(' ', Style.Space * 1);
gen.Append($"public IPropertyBag PropertyBag => {PropertyBagStaticVarName};");
gen.Append(Environment.NewLine); gen.Append(Environment.NewLine);
gen.Append(' ', Style.Space * 1);
const AccessModifiers modifiers = AccessModifiers.Private | AccessModifiers.Static | AccessModifiers.Readonly;
gen.Append($"{string.Join(" ", ModifiersToStrings(modifiers))} PropertyBag {PropertyBagStaticVarName};");
// TODO should be ordered (after property wrappers creation)
var propertyBagInitializers = propertyNames != null
? string.Join(", ", propertyNames)
: string.Empty;
var initializer = $@"new PropertyBag(new List<IProperty>{{
{propertyBagInitializers}
}}.ToArray())";
AddStaticConstructorInStageFragment(
ConstructorStage.PropertyInitializationStage,
new CSharpGenerationFragmentContext()
{
Scope = scope,
Fragment = $"{PropertyBagStaticVarName} = {initializer};"
})
;
gen.Append(Environment.NewLine); gen.Append(Environment.NewLine);
}
public FieldDefinitionExpression(string propertyName, Type propertyType, bool isPredeclaration, AccessModifiers accessModifiers = AccessModifiers.Public)
{
this.PropertyType = propertyType;
this.PropertyName = propertyName;
this.IsPredeclaration = isPredeclaration;
this.AccessModifiers = accessModifiers;
}
internal bool MemberShouldBeVisible(MemberInfo member)
{
if (ShowNonPublic)
{
return(true);
}
AccessModifiers effectiveAccess = NetMemberBrowserInfo.GetMemberAccess(member);
switch (effectiveAccess)
{
case AccessModifiers.Public:
case AccessModifiers.Protected:
case AccessModifiers.ProtectedInternal:
return(true);
case AccessModifiers.Internal:
case AccessModifiers.Private:
case AccessModifiers.Unknown:
return(false);
default:
Debug.Fail("Unexpected AccessModifiers value: " + effectiveAccess.ToString());
return(false);
}
}
public TextAsMethod(string name, AccessModifiers accessModifiers, Modifiers modifiers, string returnValue)
{
Name = name;
AccessModifier = accessModifiers;
Modifiers = modifiers;
ReturnValue = returnValue;
}
private static String AccessModifiersToString(AccessModifiers accessModifiers)
{
var result = "";
if ((accessModifiers & AccessModifiers.Public) != 0)
{
result += "public ";
}
else if ((accessModifiers & AccessModifiers.Private) != 0)
{
result += "private ";
}
else if ((accessModifiers & AccessModifiers.Protected) != 0)
{
result += "protected ";
}
if ((accessModifiers & AccessModifiers.Static) != 0)
{
result += "static ";
}
if ((accessModifiers & AccessModifiers.Constant) != 0)
{
result += "final ";
}
return(result);
}
private static List <string> ModifiersToStrings(AccessModifiers modifiers)
{
var s = new List <string>();
// TODO fairly bad, no semantics and not forced to handle all modifiers
if (modifiers.HasFlag(AccessModifiers.Public))
{
s.Add("public");
}
if (modifiers.HasFlag(AccessModifiers.Private))
{
s.Add("private");
}
if (modifiers.HasFlag(AccessModifiers.Protected))
{
s.Add("protected");
}
if (modifiers.HasFlag(AccessModifiers.Static))
{
s.Add("static");
}
if (modifiers.HasFlag(AccessModifiers.Abstract))
{
s.Add("abstract");
}
if (modifiers.HasFlag(AccessModifiers.Partial))
{
s.Add("partial");
}
if (modifiers.HasFlag(AccessModifiers.Readonly))
{
s.Add("readonly");
}
return(s);
}
public void GetAccessModifiers_ShouldReturnTheCorrectAccessModifier(string name, int am)
{
AccessModifiers accessModifiers = (AccessModifiers)am;
CSharpCompilation compilation = CreateCompilation
(@"
interface IInterface
{
void Foo();
void Bar();
}
class MyClass: IInterface
{
public void Foo() {}
void IInterface.Bar() {}
public void Baz() {}
internal void FooBar() {}
}
");
var visitor = new FindAllTypesVisitor();
visitor.VisitNamespace(compilation.GlobalNamespace);
IMethodSymbol[] methods = visitor
.AllTypeSymbols
.Single(t => t.Name == "MyClass")
.GetMembers()
.OfType <IMethodSymbol>()
.ToArray();
Assert.That(methods.Single(m => m.StrippedName() == name).GetAccessModifiers(), Is.EqualTo(accessModifiers));
}
public TextAsClass(string name, AccessModifiers accessModifiers, Modifiers modifiers, List <Propertie> properties, List <TextAsMethod> methods)
{
Name = name;
AccessModifier = accessModifiers;
Modifiers = modifiers;
Properties = properties;
MethodLists = methods;
}
public FieldDeclaration(string name, string tName, bool isGenerical, AccessModifiers accessModifiers, List <string> genericalParams)
{
_name = name;
_typeName = tName;
_isGenerical = isGenerical;
_accessModifiers = accessModifiers;
_genericalParams = genericalParams;
}
public DeclaredMethodData(MethodId methodId, string name, string signature, string genericSignature, AccessModifiers modifiers)
{
MethodId = methodId;
Name = name;
Signature = signature;
GenericSignature = genericSignature;
Modifiers = modifiers;
}
public DeclaredFieldData(FieldId fieldId, string name, string signature, string genericSignature, AccessModifiers modifiers)
{
FieldId = fieldId;
Name = name;
Signature = signature;
GenericSignature = genericSignature;
Modifiers = modifiers;
}
protected FuncDefNode AssertFunctionSignature(string src,
int line,
string fname,
string returnType = "void",
bool isVariadic = false,
AccessModifiers access = AccessModifiers.Unspecified,
QualifierFlags qualifiers = QualifierFlags.None,
params (string Type, string Identifier)[] @params)
public DeclaredFieldData(FieldId fieldId, string name, string signature, string genericSignature, AccessModifiers modifiers)
{
FieldId = fieldId;
Name = name;
Signature = signature;
GenericSignature = genericSignature;
Modifiers = modifiers;
}
public DeclaredMethodData(MethodId methodId, string name, string signature, string genericSignature, AccessModifiers modifiers)
{
MethodId = methodId;
Name = name;
Signature = signature;
GenericSignature = genericSignature;
Modifiers = modifiers;
}
public void CalculateChangeHandlesAllPossibleValues(AccessModifiers oldValue, AccessModifiers newValue)
{
var sut = new AccessModifiersChangeTable();
Action action = () => sut.CalculateChange(oldValue, newValue);
action.Should().NotThrow();
}
private static void ThirdWeekExamples()
{
Console.WriteLine("Instance of AccessModifiers() called myAccMod1");
AccessModifiers myAccMod1 = new AccessModifiers();
Console.WriteLine("Instance of AccessModifiers() called myAccMod2");
AccessModifiers myAccMod2 = new AccessModifiers("This one Has a String");
Console.WriteLine("Indexer Example");
myAccMod1.IndexerExample();
Console.WriteLine("ClassFinalizerSample Class Definitions");
ClassFinalizerSample myCFS = new ClassFinalizerSample();
ClassFinalizerSample myCFS2 = new ClassFinalizerSample("Johnny Quest", 4538702);
ClassFinalizerSample myCFS3 = new ClassFinalizerSample("Johnny Quest");
Console.WriteLine("Class Grades Assignment");
ClassGrades myClassGrades = new ClassGrades("Joe ", "Smith", 'E');
(string firstName, string lastName, char Grades) = myClassGrades;
Console.WriteLine($"Person Details: First Name: {firstName}, Last Name: {lastName}, Grade: {Grades}");
Console.WriteLine("Example of using NameOf");
Console.WriteLine(myClassGrades.MyGradeType());
DevelopmentClass myDevelopment = new DevelopmentClass();
int x, y;
x = myDevelopment.ClassTotal;
y = myDevelopment.RoomTotal;
Console.WriteLine($"Class Total: {x}, RoomTotal: {y}");
Hatchback myHatchback1 = new Hatchback();
myHatchback1.Color();
myHatchback1.Size();
myHatchback1.Speed();
myHatchback1.Weight();
Console.WriteLine(StaticExample.AddTwoNumbers(1, 2));
Console.WriteLine(Math.Abs(-10));
String Name = "Bob";
if (IsPalinDrome.IsPalindrome(Name))
{
Console.WriteLine($"{Name} is a palindrome");
}
else
{
Console.WriteLine($"{Name} is not a palindrome");
}
if (IsPalinDrome.IsPalindrome(Name = "Sarah"))
{
Console.WriteLine($"{Name} is a palindrome");
}
else
{
Console.WriteLine($"{Name} is not a palindrome");
}
}
private static string GenerateBackingField(string propType,
string fieldName,
AccessModifiers modifiers
)
{
var accessModifiers = string.Join(" ", ModifiersToStrings(modifiers));
return($"{accessModifiers} {propType} m_{fieldName}");
}
/// <summary>
/// <paramref name="access"/>> enum <paramref name="enumName"/> [: <paramref name="baseName"/>]
/// {
/// </summary>
/// <param name="access">Access modifiers</param>
/// <param name="enumName">Name of the enum</param>
/// <param name="baseName">optional base type name</param>
public void StartEnum(AccessModifiers access, string enumName, string? baseName)
{
WriteIndent();
_writer.Write($"{access.ToCode()} enum {enumName}");
if (!String.IsNullOrEmpty(baseName))
_writer.Write($" : {baseName}");
_writer.WriteLine();
WriteIndent();
_writer.WriteLine("{");
IncrementIndent();
}
/// <summary>
/// <paramref name="access"/> <paramref name="modifiers"/> <paramref name="keyword"/> <paramref name="className"/> [: <paramref name="baseNames"/>]
/// {
/// </summary>
/// <param name="access">Access modifiers</param>
/// <param name="modifiers">class modifiers</param>
/// <param name="keyword">class, record or struct</param>
/// <param name="className">Class name</param>
/// <param name="baseNames">Base class and/or interface names.</param>
public void StartClass(AccessModifiers access, ClassModifiers modifiers, ClassKeyword keyword, string className, params string[]? baseNames)
{
WriteIndent();
_writer.Write($"{access.ToCode()} {modifiers.ToCode()} {keyword.ToCode()} {className}");
if (baseNames is not null && baseNames.Length > 0)
_writer.Write($" : {String.Join(", ", baseNames)}");
_writer.WriteLine();
WriteIndent();
_writer.WriteLine("{");
IncrementIndent();
}
public PropertyDeclaration(string name, string tName, bool isGenerical, bool canBeRead, bool canBeWrite,
AccessorsModifiers accessorsModifiers, List <string> genericalParams)
{
_name = name;
_typeName = tName;
_isGenerical = isGenerical;
_canBeRead = canBeRead;
_canBeWrite = canBeWrite;
_accessModifiers = accessorsModifiers;
_genericalParams = genericalParams;
}
// @formatter:on — enable formatter after this line
public void CalculateChangeReturnsExpectedValue(
AccessModifiers oldValue,
AccessModifiers newValue,
SemVerChangeType expected)
{
var sut = new AccessModifiersChangeTable();
var actual = sut.CalculateChange(oldValue, newValue);
actual.Should().Be(expected);
}
internal DynamicInvoke(MethodInfo methodInfo, AccessModifiers access, VisibilityModifiers visibility,
InvokeDelegate invokeDelegate) : base(methodInfo)
{
MethodInfo = methodInfo;
InvokeDelegate = invokeDelegate ?? throw new ArgumentNullException(nameof(invokeDelegate));
Access = access;
Visibility = visibility;
Parameters = methodInfo.GetParameters();
ParameterTypes = Parameters.Select(p => p.ParameterType).ToArray();
ReturnType = methodInfo.ReturnType;
}
internal bool TypeShouldBeVisible(Type type)
{
if (ShowNonPublic)
{
return(true);
}
AccessModifiers effectiveAccess = NetTypeBrowserInfo.GetEffectiveTypeAccess(type);
return(effectiveAccess != AccessModifiers.Private && effectiveAccess != AccessModifiers.Internal);
}
internal ILProperty(ILCoder coding, ILVariable instance, ILPropertyBuilder propertyBuilder)
{
this.Coding = coding;
this._instance = instance;
this._getMethodBuilder = propertyBuilder.GetMethod;
this._setMethodBuilder = propertyBuilder.SetMethod;
this.PropertyType = propertyBuilder.PropertyType;
this.GetModifier = propertyBuilder.GetMethod == null ? AccessModifiers.Private : propertyBuilder.GetModifier;
this.SetModifier = propertyBuilder.SetMethod == null ? AccessModifiers.Private : propertyBuilder.SetModifier;
}
public MethodDefinitionExpression(string name, ReadOnlyCollection<Expression> parameters, AccessModifiers accessModifiers, Type returnType, Expression body, bool isPredeclaration, string rawAttributes = "", ReadOnlyDictionary<string, string> attributes = null, IEnumerable<Exception> exceptions = null)
{
this.RawAttributes = rawAttributes;
this.Attributes = attributes ?? new ReadOnlyDictionary<string, string>(new Dictionary<string, string>());
this.Name = name;
this.AccessModifiers = accessModifiers;
this.ReturnType = returnType;
this.Parameters = parameters;
this.Body = body;
this.IsPredeclaration = isPredeclaration;
this.Exceptions = exceptions?.ToReadOnlyCollection();
}
protected TypeComponent(VirtualMachine virtualMachine, ReferenceType declaringType, string name, string signature, string genericSignature, AccessModifiers modifiers)
: base(virtualMachine)
{
Contract.Requires(virtualMachine != null);
Contract.Requires<ArgumentNullException>(declaringType != null, "declaringType");
_declaringType = declaringType;
_name = name;
_signature = signature;
_genericSignature = genericSignature;
_modifiers = modifiers;
}
internal Method(VirtualMachine virtualMachine, ReferenceType declaringType, string name, string signature, string genericSignature, AccessModifiers modifiers, MethodId methodId)
: base(virtualMachine, declaringType, name, signature, genericSignature, modifiers)
{
Contract.Requires(virtualMachine != null);
_methodId = methodId;
List<string> argumentTypeSignatures;
string returnTypeSignature;
SignatureHelper.ParseMethodSignature(signature, out argumentTypeSignatures, out returnTypeSignature);
_argumentTypeSignatures = argumentTypeSignatures.AsReadOnly();
_argumentTypeNames = argumentTypeSignatures.Select(SignatureHelper.DecodeTypeName).ToList().AsReadOnly();
_returnTypeSignature = returnTypeSignature;
_returnTypeName = SignatureHelper.DecodeTypeName(_returnTypeSignature);
}
public static void SetAccessModifier(this MethodDefinition method, AccessModifiers access)
{
method.Attributes &= ~(MethodAttributes.Family | MethodAttributes.Assembly |
MethodAttributes.Private | MethodAttributes.Public);
switch (access)
{
case AccessModifiers.Protected:
method.Attributes |= MethodAttributes.Family;
return;
case AccessModifiers.Internal:
method.Attributes |= MethodAttributes.Assembly;
return;
case AccessModifiers.Private:
method.Attributes |= MethodAttributes.Private;
return;
case AccessModifiers.Public:
method.Attributes |= MethodAttributes.Public;
return;
default:
throw new Exception();
}
}
public MethodDefinitionExpression(string name, IEnumerable<Expression> parameters, AccessModifiers accessModifiers, Type returnType, Expression body, bool isPredeclaration, string rawAttributes = "", ReadOnlyDictionary<string, string> attributes = null, IEnumerable<Exception> exceptions = null)
: this(name, parameters.ToReadOnlyCollection(), accessModifiers, returnType, body, isPredeclaration, rawAttributes, attributes, exceptions)
{
}
public jvmtiError GetClassModifiers(JniEnvironment nativeEnvironment, ReferenceTypeId declaringType, out AccessModifiers modifiers)
{
modifiers = 0;
using (var @class = VirtualMachine.GetLocalReferenceForClass(nativeEnvironment, declaringType))
{
if ([email protected])
return jvmtiError.InvalidClass;
JvmAccessModifiers modifiersPtr;
jvmtiError error = RawInterface.GetClassModifiers(this, @class.Value, out modifiersPtr);
if (error != jvmtiError.None)
return error;
modifiers = (AccessModifiers)modifiersPtr;
return jvmtiError.None;
}
}
private static String AccessModifiersToString(AccessModifiers accessModifiers)
{
var result = "";
if ((accessModifiers & AccessModifiers.Public) != 0)
{
result += "public ";
}
else if ((accessModifiers & AccessModifiers.Private) != 0)
{
result += "private ";
}
else if ((accessModifiers & AccessModifiers.Protected) != 0)
{
result += "protected ";
}
if ((accessModifiers & AccessModifiers.Static) != 0)
{
result += "static ";
}
if ((accessModifiers & AccessModifiers.Constant) != 0)
{
result += "const ";
}
if ((accessModifiers & AccessModifiers.ReadOnly) != 0)
{
result += "readonly ";
}
return result;
}
public FieldDefinitionExpression(string propertyName, Type propertyType, AccessModifiers accessModifiers = AccessModifiers.Public)
: this(propertyName, propertyType, false, accessModifiers)
{
}
public Error GetModifiers(out AccessModifiers modifiers, ReferenceTypeId referenceType)
{
byte[] packet = new byte[HeaderSize + ReferenceTypeIdSize];
int id = GetMessageId();
SerializeHeader(packet, id, ReferenceTypeCommand.Modifiers);
WriteReferenceTypeId(packet, HeaderSize, referenceType);
byte[] response = SendPacket(id, packet);
Error errorCode = ReadErrorCode(response);
if (errorCode != Error.None)
{
modifiers = default(AccessModifiers);
return errorCode;
}
int offset = HeaderSize;
modifiers = (AccessModifiers)ReadInt32(response, ref offset);
return Error.None;
}
public Error GetModifiers(ReferenceTypeId referenceType, out AccessModifiers modifiers)
{
modifiers = default(AccessModifiers);
JniEnvironment nativeEnvironment;
JvmtiEnvironment environment;
jvmtiError error = GetEnvironment(out environment, out nativeEnvironment);
if (error != jvmtiError.None)
return GetStandardError(error);
error = environment.GetClassModifiers(nativeEnvironment, referenceType, out modifiers);
return GetStandardError(error);
}