private static void PopulateField(System.Reflection.FieldInfo field, string value, T target) { if (field.FieldType == typeof(int)) { field.SetValue(target, ParseInt(value)); } else if (field.FieldType == typeof(string)) { field.SetValue(target, value); } else if (field.FieldType == typeof(float)) { field.SetValue(target, ParseFloat(value)); } else if (field.FieldType == typeof(bool)) { field.SetValue(target, value == "true"); } else if (field.FieldType.IsEnum) { System.Reflection.FieldInfo val = field.FieldType.GetField(value.Replace(' ', '_')); if (val != null) { field.SetValue(target, val.GetRawConstantValue()); } else { field.SetValue(target, field.FieldType.GetField("nil").GetRawConstantValue()); } } }
static object PrettyPrintField(FieldInfo fi) { return " " + (fi.IsLiteral ? "const " : (fi.IsStatic ? "static " : "") + (fi.IsInitOnly ? "readonly " : "")) + ObjectToCode.GetCSharpFriendlyTypeName(fi.FieldType) + " " + fi.Name + (fi.IsLiteral ? " = " + ObjectToCode.ComplexObjectToPseudoCode(fi.GetRawConstantValue()) : "") ; }
// Check if the current field has the supplied value. private static string GetNameIfMatches(ServiceAttributeId id, System.Reflection.FieldInfo curField) { object rawValue; // Does this require less permissions than the GetValue version. rawValue = curField.GetRawConstantValue(); ServiceAttributeId fieldValue = (ServiceAttributeId)rawValue; if (fieldValue == id) { string fieldName = curField.Name; return(fieldName); } return(null); }
public FieldDetail(RootDetail parent, FieldInfo fi) : base(parent, fi) { _name = fi.Name; _visibility = VisibilityUtil.GetVisibilityFor(fi); _category = "field"; CodeStringBuilder csb = new CodeStringBuilder(); AppendAttributesDeclaration(csb); csb.Mode = AppendMode.Html; csb.AppendVisibility(_visibility); csb.AppendText(" "); csb.Mode = AppendMode.Both; if (fi.IsLiteral) { csb.AppendKeyword("const "); } else if (fi.IsStatic) { csb.AppendKeyword("static "); } if (fi.IsInitOnly) { csb.AppendKeyword("readonly "); } csb.AppendType(fi.FieldType); csb.AppendText(" "); csb.AppendText(fi.Name); if (fi.IsLiteral) { csb.AppendParameterValue(fi.GetRawConstantValue()); } _declaration = csb.ToString(); _declarationHtml = csb.ToHtmlString(); }
public static RxFieldInfo Build(Compiler context, RxTypeInfo typeInfo, FieldInfo fieldInfo, XElement fieldMemberElement, string xid) { RxFieldInfo instance = new RxFieldInfo(); instance.id = xid; instance.caption = instance.memberName = fieldInfo.Name; instance.SetUri(typeInfo, string.Concat("#", fieldInfo.Name)); instance.BuildComments(context, fieldMemberElement); instance.isPublic = fieldInfo.IsPublic; instance.isStatic = fieldInfo.IsStatic; instance.isLiteral = fieldInfo.IsLiteral; if (fieldInfo.IsLiteral) { instance.literalValue = fieldInfo.GetRawConstantValue().ToString(); } instance.memberInfo = fieldInfo; instance.fieldTypeRef = fieldInfo.FieldType.ToXMemberRef(); //BuildAttributesElement(memberElement, memberInfo.GetCustomAttributes(false)); return instance; }
static StackObject *GetRawConstantValue_25(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.Reflection.FieldInfo instance_of_this_method = (System.Reflection.FieldInfo) typeof(System.Reflection.FieldInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = instance_of_this_method.GetRawConstantValue(); object obj_result_of_this_method = result_of_this_method; if (obj_result_of_this_method is CrossBindingAdaptorType) { return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance, true)); } return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method, true)); }
static void ProcessField(XmlDocument output, XmlElement container, Dictionary<string, XmlElement> lookup, Type type, FieldInfo field) { if ((field.Attributes & FieldAttributes.SpecialName) != 0) { return; } var fieldXmlName = "F:"; fieldXmlName += GetTypeXmlName(type) + "."; fieldXmlName += field.Name; XmlElement docs = null; if (lookup.ContainsKey(fieldXmlName)) { docs = lookup[fieldXmlName]; } Console.WriteLine("## Processing documentation for " + fieldXmlName); var fieldElem = output.CreateElement("Field"); container.AppendChild(fieldElem); fieldElem.SetAttribute("Name", field.Name); fieldElem.SetAttribute("Anchor", GetAnchor(field)); fieldElem.SetAttribute("IsPublic", field.IsPublic ? "True" : "False"); fieldElem.SetAttribute("IsProtected", field.IsFamily ? "True" : "False"); fieldElem.SetAttribute("IsPrivate", field.IsPrivate ? "True" : "False"); fieldElem.SetAttribute("TypeName", field.FieldType.Name); fieldElem.SetAttribute("TypeNamespace", field.FieldType.Namespace); fieldElem.SetAttribute("TypeFullName", field.FieldType.FullName); fieldElem.SetAttribute("TypeAnchor", GetAnchor(field.FieldType)); try { var constVal = field.GetRawConstantValue(); if (constVal != null) { if (constVal is string) { fieldElem.SetAttribute("ConstValue", "\"" + field.GetRawConstantValue().ToString().Replace("\\","\\\\").Replace("\"", "\\\"") + "\""); } else { fieldElem.SetAttribute("ConstValue", field.GetRawConstantValue().ToString()); } } else { fieldElem.SetAttribute("ConstValue", "null"); } } catch (InvalidOperationException ex) { } if (docs != null) { PortElementFromDocs(field, docs, "summary", fieldElem, "Summary"); PortElementFromDocs(field, docs, "value", fieldElem, "Value"); } }
private string GetConstantValue(FieldInfo constant) { var value = constant.GetRawConstantValue().ToString(); return value; }
public FieldSpec CreateField (FieldInfo fi, TypeSpec declaringType) { Modifiers mod = 0; var fa = fi.Attributes; switch (fa & FieldAttributes.FieldAccessMask) { case FieldAttributes.Public: mod = Modifiers.PUBLIC; break; case FieldAttributes.Assembly: mod = Modifiers.INTERNAL; break; case FieldAttributes.Family: mod = Modifiers.PROTECTED; break; case FieldAttributes.FamORAssem: mod = Modifiers.PROTECTED | Modifiers.INTERNAL; break; default: // Ignore private fields (even for error reporting) to not require extra dependencies if (IgnorePrivateMembers || HasAttribute (CustomAttributeData.GetCustomAttributes (fi), "CompilerGeneratedAttribute", CompilerServicesNamespace)) return null; mod = Modifiers.PRIVATE; break; } var definition = new ImportedMemberDefinition (fi); TypeSpec field_type; try { field_type = ImportType (fi.FieldType, new DynamicTypeReader (fi)); } catch (Exception e) { // TODO: I should construct fake TypeSpec based on TypeRef signature // but there is no way to do it with System.Reflection throw new InternalErrorException (e, "Cannot import field `{0}.{1}' referenced in assembly `{2}'", declaringType.GetSignatureForError (), fi.Name, declaringType.MemberDefinition.DeclaringAssembly); } if ((fa & FieldAttributes.Literal) != 0) { var c = Constant.CreateConstantFromValue (field_type, fi.GetRawConstantValue (), Location.Null); return new ConstSpec (declaringType, definition, field_type, fi, mod, c); } if ((fa & FieldAttributes.InitOnly) != 0) { if (field_type == TypeManager.decimal_type) { var dc = ReadDecimalConstant (CustomAttributeData.GetCustomAttributes (fi)); if (dc != null) return new ConstSpec (declaringType, definition, field_type, fi, mod, dc); } mod |= Modifiers.READONLY; } else { if (HasVolatileModifier (fi)) mod |= Modifiers.VOLATILE; } if ((fa & FieldAttributes.Static) != 0) { mod |= Modifiers.STATIC; } else { // Fixed buffers cannot be static if (declaringType.IsStruct && field_type.IsStruct && field_type.IsNested && HasAttribute (CustomAttributeData.GetCustomAttributes (fi), "FixedBufferAttribute", CompilerServicesNamespace)) { // TODO: Sanity check on field_type (only few type are allowed) var element_field = CreateField (fi.FieldType.GetField (FixedField.FixedElementName), declaringType); return new FixedFieldSpec (declaringType, definition, fi, element_field, mod); } } return new FieldSpec (declaringType, definition, field_type, fi, mod); }
public static string FormatField(FieldInfo field) { var builder = new StringBuilder(); builder.Append(FourSpaces); if (field.IsPublic) { builder.Append("public "); } if (field.IsAssembly) { builder.Append("internal "); } if (field.IsFamily) { builder.Append("protected "); } if (field.IsStatic) { builder.Append("static "); } if (field.IsInitOnly) { builder.Append("readonly "); } builder.Append(FormatType(field.FieldType)); builder.Append(" "); builder.Append(field.Name); if (field.IsLiteral) { try { var obj = field.GetRawConstantValue(); if (obj is int) { builder.Append(" = " + (int)obj + ";"); } else if (obj is long) { builder.Append(" = " + (long)obj + "L;"); } else { builder.Append(";"); } } catch (InvalidOperationException) { builder.Append(";"); } } else { builder.Append(";"); } return builder.ToString(); }
private static void InternalSetConstant(FieldInfo fi, JavaArchiveReflectorFieldInfo yi) { // X:\jsc.svn\examples\java\Test\TestJavaFinalIntegerField\TestJavaFinalIntegerField\Program.cs var RawConstantValue = fi.GetRawConstantValue(); if (RawConstantValue == null) { // wtf? //001b ScriptCoreLibAndroid.Natives android.os.Parcelable //System.InvalidOperationException: SetConstant { FieldName = EMPTY_STATE, FieldType = android.view.AbsSavedState } yi.IsLiteral = false; // enum? return; } var RawConstantValueType = RawConstantValue.GetType(); if (RawConstantValueType == typeof(int)) yi.LiteralInt32 = (int)RawConstantValue; else if (RawConstantValueType == typeof(short)) yi.LiteralInt16 = (short)RawConstantValue; else if (RawConstantValueType == typeof(long)) yi.LiteralInt64 = (long)RawConstantValue; else if (RawConstantValueType == typeof(sbyte)) yi.LiteralInt8 = (byte)(sbyte)RawConstantValue; else if (fi.FieldType == typeof(string)) yi.LiteralString = (string)RawConstantValue; else { //Console.WriteLine( //"InternalSetConstant " + new { fi.DeclaringType.FullName, fi.Name, RawConstantValueType, fi.FieldType } // ); yi.IsLiteral = false; } //throw new InvalidOperationException( //); }
private static void ValidateSourceEqual(this FieldInfo targetField, FieldInfo sourceField, Tuple<string, string> rootTargetAndSourceFullNames) { Contract.Requires(targetField != null); Contract.Requires(rootTargetAndSourceFullNames != null); Contract.Requires(rootTargetAndSourceFullNames.Item1 != null); Contract.Requires(rootTargetAndSourceFullNames.Item2 != null); Contract.Requires(rootTargetAndSourceFullNames.Item1 != rootTargetAndSourceFullNames.Item2); Assert.That(sourceField != null, "Could not find source type"); Assert.That(sourceField != targetField); Assert.That(sourceField.Attributes == targetField.Attributes); Assert.That(sourceField.DeclaringType != targetField.DeclaringType); Assert.That(sourceField.IsAssembly == targetField.IsAssembly); Assert.That(sourceField.IsFamily == targetField.IsFamily); Assert.That(sourceField.IsFamilyAndAssembly == targetField.IsFamilyAndAssembly); Assert.That(sourceField.IsFamilyOrAssembly == targetField.IsFamilyOrAssembly); Assert.That(sourceField.IsInitOnly == targetField.IsInitOnly); Assert.That(sourceField.IsLiteral == targetField.IsLiteral); Assert.That(sourceField.IsNotSerialized == targetField.IsNotSerialized); Assert.That(sourceField.IsPinvokeImpl == targetField.IsPinvokeImpl); Assert.That(sourceField.IsPrivate == targetField.IsPrivate); Assert.That(sourceField.IsPublic == targetField.IsPublic); Assert.That(sourceField.IsSecurityCritical == targetField.IsSecurityCritical); Assert.That(sourceField.IsSecuritySafeCritical == targetField.IsSecuritySafeCritical); Assert.That(sourceField.IsSecurityTransparent == targetField.IsSecurityTransparent); Assert.That(sourceField.IsSpecialName == targetField.IsSpecialName); Assert.That(sourceField.IsStatic == targetField.IsStatic); Assert.That(sourceField.MemberType == targetField.MemberType); Assert.That(sourceField.Name == targetField.Name); targetField.FieldType.ValidateSourceNameEqual(sourceField.FieldType, rootTargetAndSourceFullNames); if (sourceField.IsLiteral) { var sourceValue = sourceField.GetRawConstantValue(); var targetValue = targetField.GetRawConstantValue(); if (sourceValue == null) { Assert.That(targetValue == null); } else { Assert.That(sourceValue.Equals(targetValue)); } } Attribute.GetCustomAttributes(targetField, false).ValidateSourceEqual(Attribute.GetCustomAttributes(sourceField, false), rootTargetAndSourceFullNames); }
internal static Object GetConstantValue(FieldInfo field) { if (field.GetType().Assembly == typeof(TypeReferences).Assembly || !field.DeclaringType.Assembly.ReflectionOnly) return field.GetValue(null); Type type = field.FieldType; Object value = field.GetRawConstantValue(); if (type.IsEnum) return MetadataEnumValue.GetEnumValue(type, value); return value; }
private string GetFieldInitLiteral(FieldInfo field) { if (!field.IsLiteral) return null; var value = field.GetRawConstantValue(); if (field.FieldType == typeof(String)) return "\"" + value.ToString() + "\""; return value.ToString(); }
public CompiledFieldScope(SymInfo si, FieldInfo fi, CompiledScope declaringType, bool is_global) { this.si = si; this.fi = fi; string[] args = declaringType.TemplateArguments; if (args != null) { generic_args = new List<string>(); generic_args.AddRange(args); } if (generic_args != null) { //TypeScope ts = declaringType.instances[fi.FieldType.GenericParameterPosition]; this.sc = CompiledScope.get_type_instance(fi.FieldType, declaringType.instances); } else this.sc = TypeTable.get_compiled_type(fi.FieldType); if (fi.IsLiteral) this.cnst_val = fi.GetRawConstantValue(); if (si.name == null) AssemblyDocCache.AddDescribeToComplete(this.si, fi); this.si.name = fi.Name; this.is_global = is_global; this.si.description = this.ToString(); //this.si.describe += "\n"+AssemblyDocCache.GetDocumentation(fi.DeclaringType.Assembly,"F:"+fi.DeclaringType.FullName+"."+fi.Name); this.topScope = declaringType; if (fi.IsPrivate) { this.acc_mod = access_modifer.private_modifer; this.si.acc_mod = access_modifer.private_modifer; } else if (fi.IsFamily || fi.IsFamilyOrAssembly) { this.acc_mod = access_modifer.protected_modifer; this.si.acc_mod = access_modifer.protected_modifer; } else if (fi.IsFamilyAndAssembly || fi.IsAssembly) { this.acc_mod = access_modifer.internal_modifer; this.si.acc_mod = access_modifer.internal_modifer; } }
public virtual string GetDescriptionForCompiledField(FieldInfo fi) { StringBuilder sb = new StringBuilder(); if (fi.IsPublic) sb.Append("public "); else if (fi.IsFamily) sb.Append("protected "); if (!fi.IsLiteral) if (fi.IsStatic) sb.Append("class "); if (!fi.IsLiteral) { sb.Append(prepare_member_name(fi.Name)); sb.Append(" : " + GetFullTypeName(fi.FieldType)); } else { sb.Append("const " + fi.Name + " : " + GetFullTypeName(fi.FieldType)); sb.Append(" = " + fi.GetRawConstantValue().ToString()); } sb.Append(";"); return sb.ToString(); }
private void MapField(TypeDefinition type_definition, FieldInfo field) { if (_options.EraseMember(field)) return; var field_definition = FieldDefinitionFor(field, type_definition); if (field_definition.HasDefault) field_definition.Constant = field.GetRawConstantValue(); if ((field_definition.Attributes & MC.FieldAttributes.HasFieldRVA) != 0) field_definition.InitialValue = GetInitialValue(field); var attributes = field.GetCustomAttributes(typeof(FieldOffsetAttribute), inherit: false); if (attributes.Length > 0) field_definition.Offset = ((FieldOffsetAttribute)attributes[0]).Value; MapCustomAttributes(field, field_definition); }
internal static PythonTypeSlot GetReflectedField(FieldInfo info) { PythonTypeSlot res; NameType nt = NameType.Field; if (!PythonBinder.IsExtendedType(info.DeclaringType) && !info.IsDefined(typeof(PythonHiddenAttribute), false)) { nt |= NameType.PythonField; } lock (_fieldCache) { if (!_fieldCache.TryGetValue(info, out res)) { if (nt == NameType.PythonField && info.IsLiteral) { if (info.FieldType == typeof(int)) { res = new PythonTypeUserDescriptorSlot( ScriptingRuntimeHelpers.Int32ToObject((int)info.GetRawConstantValue()), true ); } else if (info.FieldType == typeof(bool)) { res = new PythonTypeUserDescriptorSlot( ScriptingRuntimeHelpers.BooleanToObject((bool)info.GetRawConstantValue()), true ); } else { res = new PythonTypeUserDescriptorSlot( info.GetValue(null), true ); } } else { res = new ReflectedField(info, nt); } _fieldCache[info] = res; } } return res; }
// adds a enumeration (keyword, opcode, task or channel) represented by 'staticField' // to the manifest. private static void AddProviderEnumKind(ManifestBuilder manifest, FieldInfo staticField, string providerEnumKind) { Type staticFieldType = staticField.FieldType; if (staticFieldType == typeof(EventOpcode)) { if (providerEnumKind != "Opcodes") goto Error; int value = (int)staticField.GetRawConstantValue(); if (value <= 10) throw new ArgumentException(Environment.GetResourceString("EventSource_ReservedOpcode")); manifest.AddOpcode(staticField.Name, value); } else if (staticFieldType == typeof(EventTask)) { if (providerEnumKind != "Tasks") goto Error; manifest.AddTask(staticField.Name, (int)staticField.GetRawConstantValue()); } else if (staticFieldType == typeof(EventKeywords)) { if (providerEnumKind != "Keywords") goto Error; manifest.AddKeyword(staticField.Name, (ulong)(long)staticField.GetRawConstantValue()); } #if FEATURE_MANAGED_ETW_CHANNELS else if (staticFieldType == typeof(EventChannel)) { if (providerEnumKind != "Channels") goto Error; var channelAttribute = (ChannelAttribute)GetCustomAttributeHelper(staticField, typeof(ChannelAttribute)); manifest.AddChannel(staticField.Name, (byte)staticField.GetRawConstantValue(), channelAttribute); } #endif return; Error: throw new ArgumentException(Environment.GetResourceString("EventSource_EnumKindMismatch", staticField.FieldType.Name, providerEnumKind)); }
static private void AppendFieldInfo(FieldInfo field, StringBuilder sb) { sb.Append(".field "); foreach (var attribute in field.GetCustomAttributesData()) { AppendCustomAttributeData(attribute, sb); sb.Append(" "); } foreach (var modreq in field.GetRequiredCustomModifiers()) { sb.Append("modreq("); AppendType(modreq, sb); sb.Append(") "); } foreach (var modopt in field.GetOptionalCustomModifiers()) { sb.Append("modopt("); AppendType(modopt, sb); sb.Append(") "); } if (field.IsPrivate) sb.Append("private "); if (field.IsPublic) sb.Append("public "); if (field.IsFamily) sb.Append("family "); if (field.IsAssembly) sb.Append("assembly "); if (field.IsFamilyOrAssembly) sb.Append("famorassem "); if (field.IsFamilyAndAssembly) sb.Append("famandassem "); if (field.IsInitOnly) sb.Append("initonly "); if (field.IsLiteral) sb.Append("literal "); if (field.IsNotSerialized) sb.Append("notserialized "); if (field.Attributes.HasFlag(FieldAttributes.SpecialName)) sb.Append("specialname "); if (field.Attributes.HasFlag(FieldAttributes.RTSpecialName)) sb.Append("rtspecialname "); if (field.IsPinvokeImpl) sb.Append("pinvokeimpl "); sb.Append(field.IsStatic ? "static " : "instance "); AppendType(field.FieldType, sb); sb.Append(" "); sb.Append(field.Name); if (field.IsLiteral) { AppendValue(field.GetRawConstantValue(), sb); } }
public static compiled_class_constant_definition GetConstantFieldNode(FieldInfo fi) { compiled_class_constant_definition cccd = field_nodes[fi] as compiled_class_constant_definition; if (cccd != null) return cccd; constant_node cn = CreateConstantNode(fi.GetRawConstantValue()); if (cn == null) return null; cccd = new compiled_class_constant_definition(fi, cn); field_nodes[fi] = cccd; return cccd; }