public FieldTableItem (FieldDef field, Location location) { flags = 0; Field = field; LocationList = new ArrayList (); LocationList.Add (location); }
public virtual DocumentTreeNodeFilterResult GetResult(FieldDef field) => new DocumentTreeNodeFilterResult(FilterType.Hide, false);
public virtual DocumentTreeNodeFilterResult GetResult(FieldDef field) => new DocumentTreeNodeFilterResult();
public override void Decompile(FieldDef field, IDecompilerOutput output, DecompilationContext ctx) { output.Write(IdentifierEscaper.Escape(field.FieldType.GetFullName()), field.FieldType.ToTypeDefOrRef(), DecompilerReferenceFlags.None, TextColorHelper.GetColor(field.FieldType)); output.Write(" ", BoxedTextColor.Text); output.Write(IdentifierEscaper.Escape(field.Name), field, DecompilerReferenceFlags.Definition, TextColorHelper.GetColor(field)); var c = field.Constant; if (c != null) { output.Write(" ", BoxedTextColor.Text); output.Write("=", BoxedTextColor.Operator); output.Write(" ", BoxedTextColor.Text); if (c.Value == null) { output.Write("null", BoxedTextColor.Keyword); } else { switch (c.Type) { case ElementType.Boolean: if (c.Value is bool) { output.Write((bool)c.Value ? "true" : "false", BoxedTextColor.Keyword); } else { goto default; } break; case ElementType.Char: output.Write($"'{c.Value}'", BoxedTextColor.Char); break; case ElementType.I1: case ElementType.U1: case ElementType.I2: case ElementType.U2: case ElementType.I4: case ElementType.U4: case ElementType.I8: case ElementType.U8: case ElementType.R4: case ElementType.R8: case ElementType.I: case ElementType.U: output.Write($"{c.Value}", BoxedTextColor.Number); break; case ElementType.String: output.Write($"{c.Value}", BoxedTextColor.String); break; default: output.Write($"{c.Value}", BoxedTextColor.Text); break; } } } }
public static bool IsInstanceField(FieldDef fldDef) { return(!fldDef.IsStatic); }
public FieldInfo(FieldDef fieldDef) : base(fieldDef) { }
ushort GetStructDef(Type type, Metadata metadata, Metadata[] fields) { var index = Schema.structs.Count; var structDef = new StructDef(); Schema.structs.Add(structDef); structDef.metadata = metadata; var baseType = type.GetBaseSchemaType(); if (baseType != null) structDef.base_def = GetTypeDef(baseType); var i = 0; foreach (var field in type.GetSchemaFields()) { var fieldDef = new FieldDef { id = field.Id, metadata = fields[i++], type = GetTypeDef(field.GetSchemaType()) }; structDef.fields.Add(fieldDef); } return (ushort) index; }
public override void DecompileField(FieldDef field, ITextOutput output, DecompilationOptions options) { var dis = CreateReflectionDisassembler(output, options, field); dis.DisassembleField(field); }
public override void DecompileField(FieldDef field, ITextOutput output, DecompilationOptions options) { var dis = new ReflectionDisassembler(output, detectControlStructure, options.CancellationToken); dis.DisassembleField(field); }
private void ProcessConverter(PropertyWithConverterRecord rec, TypeDef type) { TypeDef converter = ResolveType(rec.ConverterTypeId); if (converter.FullName == "System.ComponentModel.EnumConverter") { if (type != null && context.Modules.Contains((ModuleDefMD)type.Module)) { FieldDef enumField = type.FindField(rec.Value); if (enumField != null) { service.AddReference(enumField, new BAMLEnumReference(enumField, rec)); } } } else if (converter.FullName == "System.Windows.Input.CommandConverter") { string cmd = rec.Value.Trim(); int index = cmd.IndexOf('.'); if (index != -1) { string typeName = cmd.Substring(0, index); string prefix; TypeSig sig = ResolveType(typeName, out prefix); if (sig != null) { string cmdName = cmd.Substring(index + 1); TypeDef typeDef = sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow(); if (context.Modules.Contains((ModuleDefMD)typeDef.Module)) { PropertyDef property = typeDef.FindProperty(cmdName); if (property != null) { var reference = new BAMLConverterMemberReference(xmlnsCtx, sig, property, rec); AddTypeSigReference(sig, reference); service.ReduceRenameMode(property, RenameMode.Letters); service.AddReference(property, reference); } FieldDef field = typeDef.FindField(cmdName); if (field != null) { var reference = new BAMLConverterMemberReference(xmlnsCtx, sig, field, rec); AddTypeSigReference(sig, reference); service.ReduceRenameMode(field, RenameMode.Letters); service.AddReference(field, reference); } if (property == null && field == null) { context.Logger.WarnFormat("Could not resolve command '{0}' in '{1}'.", cmd, CurrentBAMLName); } } } } } else if (converter.FullName == "System.Windows.Markup.DependencyPropertyConverter") { // Umm... Again nothing to do, DP already won't be renamed. } else if (converter.FullName == "System.Windows.PropertyPathConverter") { AnalyzePropertyPath(rec.Value); } else if (converter.FullName == "System.Windows.Markup.RoutedEventConverter") { ; } else if (converter.FullName == "System.Windows.Markup.TypeTypeConverter") { string prefix; TypeSig sig = ResolveType(rec.Value.Trim(), out prefix); if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module)) { var reference = new BAMLConverterTypeReference(xmlnsCtx, sig, rec); AddTypeSigReference(sig, reference); } } var attrInfo = ResolveAttribute(rec.AttributeId); string attrName = null; if (attrInfo.Item1 != null) { attrName = attrInfo.Item1.Name; } else if (attrInfo.Item2 != null) { attrName = attrInfo.Item2.Name; } if (attrName == "DisplayMemberPath") { AnalyzePropertyPath(rec.Value); } else if (attrName == "Source") { string declType = null; if (attrInfo.Item1 is IMemberDef) { declType = ((IMemberDef)attrInfo.Item1).DeclaringType.FullName; } else if (attrInfo.Item2 != null) { declType = ResolveType(attrInfo.Item2.OwnerTypeId).FullName; } if (declType == "System.Windows.ResourceDictionary") { var src = rec.Value.ToUpperInvariant(); if (src.EndsWith(".BAML") || src.EndsWith(".XAML")) { var match = WPFAnalyzer.UriPattern.Match(src); if (match.Success) { src = match.Groups[1].Value; } else if (rec.Value.Contains("/")) { context.Logger.WarnFormat("Fail to extract XAML name from '{0}'.", rec.Value); } if (!src.Contains("//")) { var rel = new Uri(new Uri(packScheme + "application:,,,/" + CurrentBAMLName), src); src = rel.LocalPath; } var reference = new BAMLPropertyReference(rec); src = src.TrimStart('/'); var baml = src.Substring(0, src.Length - 5) + ".BAML"; var xaml = src.Substring(0, src.Length - 5) + ".XAML"; var bamlRefs = service.FindRenamer <WPFAnalyzer>().bamlRefs; bamlRefs.AddListEntry(baml, reference); bamlRefs.AddListEntry(xaml, reference); bamlRefs.AddListEntry(Uri.EscapeUriString(baml), reference); bamlRefs.AddListEntry(Uri.EscapeUriString(xaml), reference); } } } }
private Schema(Type trow) { lock (s_TypeLatch) { if (s_TypeLatch.Contains(trow)) { throw new CRUDException(StringConsts.CRUD_TYPED_ROW_RECURSIVE_FIELD_DEFINITION_ERROR.Args(trow.FullName)); } s_TypeLatch.Add(trow); try { m_Name = trow.AssemblyQualifiedName; var tattrs = trow.GetCustomAttributes(typeof(TableAttribute), false).Cast <TableAttribute>(); m_TableAttrs = new List <TableAttribute>(tattrs); m_FieldDefs = new OrderedRegistry <FieldDef>(); var props = GetFieldMembers(trow); var order = 0; foreach (var prop in props) { var fattrs = prop.GetCustomAttributes(typeof(FieldAttribute), false) .Cast <FieldAttribute>() .ToArray(); //20160318 DKh. Interpret [Field(CloneFromType)] for (var i = 0; i < fattrs.Length; i++) { var attr = fattrs[i]; if (attr.CloneFromRowType == null) { continue; } if (fattrs.Length > 1) { throw new CRUDException(StringConsts.CRUD_TYPED_ROW_SINGLE_CLONED_FIELD_ERROR.Args(trow.FullName, prop.Name)); } var clonedSchema = Schema.GetForTypedRow(attr.CloneFromRowType); var clonedDef = clonedSchema[prop.Name]; if (clonedDef == null) { throw new CRUDException(StringConsts.CRUD_TYPED_ROW_CLONED_FIELD_NOTEXISTS_ERROR.Args(trow.FullName, prop.Name)); } fattrs = clonedDef.Attrs.ToArray();//replace these attrs from the cloned target break; } var fdef = new FieldDef(prop.Name, order, prop.PropertyType, fattrs, prop); m_FieldDefs.Register(fdef); order++; } s_TypedRegistry.Register(this); m_TypedRowType = trow; } finally { s_TypeLatch.Remove(trow); } } //lock }
protected override void GetCallInfo(object context, FieldDef field, out IMethod calledMethod, out OpCode callOpcode) { calledMethod = module.ResolveToken(0x06000000 + field.MDToken.ToInt32()) as IMethod; callOpcode = OpCodes.Call; }
public FieldAccessNode(FieldDef analyzedField, bool showWrites) { this.analyzedField = analyzedField ?? throw new ArgumentNullException(nameof(analyzedField)); this.showWrites = showWrites; }
public RuntimeSchema GetFieldSchema(FieldDef field) { Debug.Assert(HasValue); return new RuntimeSchema(schemaDef, field.type); }
/// <summary> /// Clones the specified origin FieldDef. /// </summary> /// <param name="origin">The origin FieldDef.</param> /// <returns>The cloned FieldDef.</returns> static FieldDefUser Clone(FieldDef origin) { var ret = new FieldDefUser(origin.Name, null, origin.Attributes); return(ret); }
// Constructors public FieldAction(TypeDef type, FieldDef field) : base(type) { Field = field; }
/// <inheritdoc/> public override uint GetRid(FieldDef fd) { uint rid; if (fieldDefInfos.TryGetRid(fd, out rid)) return rid; if (fd == null) Error("Field is null"); else Error("Field {0} ({1:X8}) is not defined in this module ({2}). A field was removed that is still referenced by this module.", fd, fd.MDToken.Raw, module); return 0; }
public void Analyze(ConfuserContext context, INameService service, IDnlibDef def) { var module = def as ModuleDefMD; if (module == null) { return; } MDTable table; uint len; // MemberRef table = module.TablesStream.Get(Table.Method); len = table.Rows; IEnumerable <MethodDef> methods = Enumerable.Range(1, (int)len) .Select(rid => module.ResolveMethod((uint)rid)); foreach (MethodDef method in methods) { foreach (MethodOverride methodImpl in method.Overrides) { if (methodImpl.MethodBody is MemberRef) { AnalyzeMemberRef(context, service, (MemberRef)methodImpl.MethodBody); } if (methodImpl.MethodDeclaration is MemberRef) { AnalyzeMemberRef(context, service, (MemberRef)methodImpl.MethodDeclaration); } } if (!method.HasBody) { continue; } foreach (Instruction instr in method.Body.Instructions) { if (instr.Operand is MemberRef) { AnalyzeMemberRef(context, service, (MemberRef)instr.Operand); } else if (instr.Operand is MethodSpec) { var spec = (MethodSpec)instr.Operand; if (spec.Method is MemberRef) { AnalyzeMemberRef(context, service, (MemberRef)spec.Method); } } } } // CustomAttribute table = module.TablesStream.Get(Table.CustomAttribute); len = table.Rows; IEnumerable <CustomAttribute> attrs = Enumerable.Range(1, (int)len) .Select(rid => module.ResolveHasCustomAttribute(module.TablesStream.ReadCustomAttributeRow((uint)rid).Parent)) .Distinct() .SelectMany(owner => owner.CustomAttributes); foreach (CustomAttribute attr in attrs) { if (attr.Constructor is MemberRef) { AnalyzeMemberRef(context, service, (MemberRef)attr.Constructor); } foreach (CAArgument arg in attr.ConstructorArguments) { AnalyzeCAArgument(context, service, arg); } foreach (CANamedArgument arg in attr.Fields) { AnalyzeCAArgument(context, service, arg.Argument); } foreach (CANamedArgument arg in attr.Properties) { AnalyzeCAArgument(context, service, arg.Argument); } TypeDef attrType = attr.AttributeType.ResolveTypeDefThrow(); if (!context.Modules.Contains((ModuleDefMD)attrType.Module)) { continue; } foreach (CANamedArgument fieldArg in attr.Fields) { FieldDef field = attrType.FindField(fieldArg.Name, new FieldSig(fieldArg.Type)); if (field == null) { context.Logger.WarnFormat("Failed to resolve CA field '{0}::{1} : {2}'.", attrType, fieldArg.Name, fieldArg.Type); } else { service.AddReference(field, new CAMemberReference(fieldArg, field)); } } foreach (CANamedArgument propertyArg in attr.Properties) { PropertyDef property = attrType.FindProperty(propertyArg.Name, new PropertySig(true, propertyArg.Type)); if (property == null) { context.Logger.WarnFormat("Failed to resolve CA property '{0}::{1} : {2}'.", attrType, propertyArg.Name, propertyArg.Type); } else { service.AddReference(property, new CAMemberReference(propertyArg, property)); } } } }
/// <summary> /// Записать таблицу dataTable в файл или поток /// </summary> public void Update(DataTable dataTable) { if (dataTable == null) throw new ArgumentNullException("dataTable"); Stream stream = null; BinaryWriter writer = null; try { stream = ioStream == null ? new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.ReadWrite) : ioStream; writer = new BinaryWriter(stream, Encoding.Default); // запись заголовка byte fieldCnt = dataTable.Columns.Count > byte.MaxValue ? byte.MaxValue : (byte)dataTable.Columns.Count; writer.Write(fieldCnt); writer.Write((ushort)0); // резерв if (fieldCnt > 0) { // формирование и запись определений полей FieldDef[] fieldDefs = new FieldDef[fieldCnt]; int recSize = 2; // размер строки в файле byte[] buf = new byte[FieldDefSize]; buf[FieldDefSize - 1] = buf[FieldDefSize - 2] = 0; // резерв for (int i = 0; i < fieldCnt; i++) { FieldDef fieldDef = new FieldDef(); DataColumn col = dataTable.Columns[i]; Type type = col.DataType; if (type == typeof(int)) { fieldDef.DataType = DataTypes.Integer; fieldDef.DataSize = sizeof(int); } else if (type == typeof(double)) { fieldDef.DataType = DataTypes.Double; fieldDef.DataSize = sizeof(double); } else if (type == typeof(bool)) { fieldDef.DataType = DataTypes.Boolean; fieldDef.DataSize = 1; } else if (type == typeof(DateTime)) { fieldDef.DataType = DataTypes.DateTime; fieldDef.DataSize = sizeof(double); } else { fieldDef.DataType = DataTypes.String; int maxLen = col.MaxLength; fieldDef.DataSize = 0 < maxLen && maxLen <= MaxStringLen ? (ushort)maxLen + 2 : (ushort)MaxStringLen + 2; } fieldDef.AllowNull = col.AllowDBNull; fieldDef.Name = col.ColumnName; recSize += fieldDef.DataSize; if (fieldDef.AllowNull) recSize++; fieldDefs[i] = fieldDef; buf[0] = (byte)fieldDef.DataType; Array.Copy(BitConverter.GetBytes((ushort)fieldDef.DataSize), 0, buf, 1, 2); buf[3] = fieldDef.AllowNull ? (byte)1 : (byte)0; ConvertStr(fieldDef.Name, MaxFieldNameLen, buf, 4); writer.Write(buf); } // запись строк buf = new byte[recSize]; buf[0] = buf[1] = 0; // резерв foreach (DataRow row in dataTable.Rows) { int bufInd = 2; foreach (FieldDef fieldDef in fieldDefs) { int colInd = dataTable.Columns.IndexOf(fieldDef.Name); object val = colInd >= 0 ? row[colInd] : null; bool isNull = val == null || val == DBNull.Value; if (fieldDef.AllowNull) buf[bufInd++] = isNull ? (byte)1 : (byte)0; switch (fieldDef.DataType) { case DataTypes.Integer: int intVal = isNull ? 0 : (int)val; Array.Copy(BitConverter.GetBytes(intVal), 0, buf, bufInd, fieldDef.DataSize); break; case DataTypes.Double: double dblVal = isNull ? 0.0 : (double)val; Array.Copy(BitConverter.GetBytes(dblVal), 0, buf, bufInd, fieldDef.DataSize); break; case DataTypes.Boolean: buf[bufInd] = (byte)(isNull ? 0 : (bool)val ? 1 : 0); break; case DataTypes.DateTime: double dtVal = isNull ? 0.0 : Arithmetic.EncodeDateTime((DateTime)val); Array.Copy(BitConverter.GetBytes(dtVal), 0, buf, bufInd, fieldDef.DataSize); break; default: string strVal = isNull ? "" : val.ToString(); ConvertStr(strVal, fieldDef.DataSize - 2, buf, bufInd); break; } bufInd += fieldDef.DataSize; } writer.Write(buf); } } } finally { if (fileMode) { if (writer != null) writer.Close(); if (stream != null) stream.Close(); } } }
public override object VisitBlockStatement(BlockStatement blockStatement, object data) { int numberOfVariablesOutsideBlock = currentlyUsedVariableNames.Count; base.VisitBlockStatement(blockStatement, data); foreach (ExpressionStatement stmt in blockStatement.Statements.OfType <ExpressionStatement>().ToArray()) { Match displayClassAssignmentMatch = displayClassAssignmentPattern.Match(stmt); if (!displayClassAssignmentMatch.Success) { continue; } ILVariable variable = displayClassAssignmentMatch.Get <AstNode>("variable").Single().Annotation <ILVariable>(); if (variable == null) { continue; } TypeDef type = variable.Type.ToTypeDefOrRef().ResolveWithinSameModule(); if (!IsPotentialClosure(context, type)) { continue; } if (displayClassAssignmentMatch.Get <AstType>("type").Single().Annotation <ITypeDefOrRef>().ResolveWithinSameModule() != type) { continue; } // Looks like we found a display class creation. Now let's verify that the variable is used only for field accesses: bool ok = true; foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>()) { if (identExpr.Identifier == variable.Name && identExpr != displayClassAssignmentMatch.Get("variable").Single()) { if (!(identExpr.Parent is MemberReferenceExpression && identExpr.Parent.Annotation <IField>() != null)) { ok = false; } } } if (!ok) { continue; } Dictionary <IField, AstNode> dict = new Dictionary <IField, AstNode>(); // Delete the variable declaration statement: VariableDeclarationStatement displayClassVarDecl = PatternStatementTransform.FindVariableDeclaration(stmt, variable.Name); if (displayClassVarDecl != null) { displayClassVarDecl.Remove(); } // Delete the assignment statement: AstNode cur = stmt.NextSibling; stmt.Remove(); // Delete any following statements as long as they assign parameters to the display class BlockStatement rootBlock = blockStatement.Ancestors.OfType <BlockStatement>().LastOrDefault() ?? blockStatement; List <ILVariable> parameterOccurrances = rootBlock.Descendants.OfType <IdentifierExpression>() .Select(n => n.Annotation <ILVariable>()).Where(p => p != null && p.IsParameter).ToList(); AstNode next; for (; cur != null; cur = next) { next = cur.NextSibling; // Test for the pattern: // "variableName.MemberName = right;" ExpressionStatement closureFieldAssignmentPattern = new ExpressionStatement( new AssignmentExpression( new NamedNode("left", new MemberReferenceExpression { Target = new IdentifierExpression(variable.Name), MemberName = Pattern.AnyString }), new AnyNode("right") ) ); Match m = closureFieldAssignmentPattern.Match(cur); if (m.Success) { FieldDef fieldDef = m.Get <MemberReferenceExpression>("left").Single().Annotation <IField>().ResolveFieldWithinSameModule(); AstNode right = m.Get <AstNode>("right").Single(); bool isParameter = false; bool isDisplayClassParentPointerAssignment = false; if (right is ThisReferenceExpression) { isParameter = true; } else if (right is IdentifierExpression) { // handle parameters only if the whole method contains no other occurrence except for 'right' ILVariable v = right.Annotation <ILVariable>(); isParameter = v.IsParameter && parameterOccurrances.Count(c => c == v) == 1; if (!isParameter && IsPotentialClosure(context, v.Type.ToTypeDefOrRef().ResolveWithinSameModule())) { // parent display class within the same method // (closure2.localsX = closure1;) isDisplayClassParentPointerAssignment = true; } } else if (right is MemberReferenceExpression) { // copy of parent display class reference from an outer lambda // closure2.localsX = this.localsY MemberReferenceExpression mre = m.Get <MemberReferenceExpression>("right").Single(); do { // descend into the targets of the mre as long as the field types are closures FieldDef fieldDef2 = mre.Annotation <IField>().ResolveFieldWithinSameModule(); if (fieldDef2 == null || !IsPotentialClosure(context, fieldDef2.FieldType.ToTypeDefOrRef().ResolveWithinSameModule())) { break; } // if we finally get to a this reference, it's copying a display class parent pointer if (mre.Target is ThisReferenceExpression) { isDisplayClassParentPointerAssignment = true; } mre = mre.Target as MemberReferenceExpression; } while (mre != null); } if (isParameter || isDisplayClassParentPointerAssignment) { dict[fieldDef] = right; cur.Remove(); } else { break; } } else { break; } } // Now create variables for all fields of the display class (except for those that we already handled as parameters) List <Tuple <AstType, ILVariable> > variablesToDeclare = new List <Tuple <AstType, ILVariable> >(); foreach (FieldDef field in type.Fields) { if (field.IsStatic) { continue; // skip static fields } if (dict.ContainsKey(field)) // skip field if it already was handled as parameter { continue; } string capturedVariableName = field.Name; if (capturedVariableName.StartsWith("$VB$Local_", StringComparison.Ordinal) && capturedVariableName.Length > 10) { capturedVariableName = capturedVariableName.Substring(10); } EnsureVariableNameIsAvailable(blockStatement, capturedVariableName); currentlyUsedVariableNames.Add(capturedVariableName); ILVariable ilVar = new ILVariable { IsGenerated = true, Name = capturedVariableName, Type = field.FieldType, }; variablesToDeclare.Add(Tuple.Create(AstBuilder.ConvertType(field.FieldType, field), ilVar)); dict[field] = new IdentifierExpression(capturedVariableName).WithAnnotation(ilVar); } // Now figure out where the closure was accessed and use the simpler replacement expression there: foreach (var identExpr in blockStatement.Descendants.OfType <IdentifierExpression>()) { if (identExpr.Identifier == variable.Name) { MemberReferenceExpression mre = (MemberReferenceExpression)identExpr.Parent; AstNode replacement; if (dict.TryGetValue(mre.Annotation <IField>().ResolveFieldWithinSameModule(), out replacement)) { mre.ReplaceWith(replacement.Clone()); } } } // Now insert the variable declarations (we can do this after the replacements only so that the scope detection works): Statement insertionPoint = blockStatement.Statements.FirstOrDefault(); foreach (var tuple in variablesToDeclare) { var newVarDecl = new VariableDeclarationStatement(tuple.Item1, tuple.Item2.Name); newVarDecl.Variables.Single().AddAnnotation(new CapturedVariableAnnotation()); newVarDecl.Variables.Single().AddAnnotation(tuple.Item2); blockStatement.Statements.InsertBefore(insertionPoint, newVarDecl); } } currentlyUsedVariableNames.RemoveRange(numberOfVariablesOutsideBlock, currentlyUsedVariableNames.Count - numberOfVariablesOutsideBlock); return(null); }
public void add(FieldDef f) { fields.add(f); }
public Form ShowTabular(string FreeFilter, object TransStartDate, object TransEndDate, params object[] Parameters) { if (!BaseWinFramework.CheckModuleAccessWithError(ModuleName, SecurityVarName.ReportView, true)) { return(null); } using (new WaitCursor()) { if (!TypeChecked) { CheckEntityType(); } if (_UIN != null) { IRuleInitUI riu = (IRuleInitUI)_UIN.Entity; _DataFilter = riu.GetBrowseFilter(); BrowseColumns = riu.GetBrowseColumns(); riu.GetBrowseSql(out BrowseSql, out BrowseCondition, out BrowseOrder); BrowseFormat.Clear(); riu.GetBrowseFormat(BrowseFormat); TableDef td = MetaData.GetTableDef(riu.GetType()); if (riu.GetFieldTransactionDate().Length == 0) { fldTransactionDate = td.fldTransactionDate; } else { fldTransactionDate = td.GetFieldDef( riu.GetFieldTransactionDate()); } } if (_BrowseForm == null || _BrowseForm.IsDisposed || _BrowseType != BrowseType.Tabular) { if (BaseWinFramework.TouchScreenVersion) { _BrowseForm = new frmGridReportTC(); } else { _BrowseForm = new frmGridReport(); } _BrowseForm.MdiParent = BaseWinFramework._MdiParent; _BrowseType = BrowseType.Tabular; ((IBrowseForm)_BrowseForm).ShowForm2(this, ModuleName, FreeFilter, TransStartDate, TransEndDate, Parameters); } else { ((IBrowseForm)_BrowseForm).ShowForm3( FreeFilter, TransStartDate, TransEndDate, Parameters); } return(_BrowseForm); } }
public FieldNodeImpl(ITreeNodeGroup treeNodeGroup, FieldDef field) : base(field) => TreeNodeGroup = treeNodeGroup;
static FieldDefUser Clone(FieldDef originalField) { return(new FieldDefUser(originalField.Name, null, originalField.Attributes)); }
public SelectFieldTransform(FieldDef field) { this.field = field; }
private FieldInfo BuildDeclaredField(TypeInfo type, FieldDef fieldDef) { BuildLog.Info(Strings.LogBuildingDeclaredFieldXY, type.Name, fieldDef.Name); var fieldInfo = new FieldInfo(type, fieldDef.Attributes) { UnderlyingProperty = fieldDef.UnderlyingProperty, Name = fieldDef.Name, OriginalName = fieldDef.Name, MappingName = fieldDef.MappingName, ValueType = fieldDef.ValueType, ItemType = fieldDef.ItemType, Length = fieldDef.Length, Scale = fieldDef.Scale, Precision = fieldDef.Precision, Validators = fieldDef.Validators, }; if (fieldInfo.IsStructure && DeclaresOnValidate(fieldInfo.ValueType)) { fieldInfo.Validators.Add(new StructureFieldValidator()); } if (fieldInfo.IsEntitySet && DeclaresOnValidate(fieldInfo.ValueType)) { fieldInfo.Validators.Add(new EntitySetFieldValidator()); } type.Fields.Add(fieldInfo); if (fieldInfo.IsEntitySet) { AssociationBuilder.BuildAssociation(context, fieldDef, fieldInfo); return(fieldInfo); } if (fieldInfo.IsEntity) { var fields = context.Model.Types[fieldInfo.ValueType].Fields.Where(f => f.IsPrimaryKey); // Adjusting default value if any if (fields.Count() == 1 && fieldDef.DefaultValue != null) { fieldInfo.DefaultValue = ValueTypeBuilder.AdjustValue(fieldInfo, fields.First().ValueType, fieldDef.DefaultValue); } BuildNestedFields(null, fieldInfo, fields); if (!IsAuxiliaryType(type)) { AssociationBuilder.BuildAssociation(context, fieldDef, fieldInfo); } // Adjusting type discriminator field for references if (fieldDef.IsTypeDiscriminator) { type.Hierarchy.TypeDiscriminatorMap.Field = fieldInfo.Fields.First(); } } if (fieldInfo.IsStructure) { BuildNestedFields(null, fieldInfo, context.Model.Types[fieldInfo.ValueType].Fields); var structureFullTextIndex = context.ModelDef.FullTextIndexes.TryGetValue(fieldInfo.ValueType); if (structureFullTextIndex != null) { var hierarchyTypeInfo = context.Model.Types[fieldInfo.DeclaringType.UnderlyingType]; var structureTypeInfo = context.Model.Types[fieldInfo.ValueType]; var currentIndex = context.ModelDef.FullTextIndexes.TryGetValue(hierarchyTypeInfo.UnderlyingType); if (currentIndex == null) { currentIndex = new FullTextIndexDef(context.ModelDef.Types.TryGetValue(type.UnderlyingType)); context.ModelDef.FullTextIndexes.Add(currentIndex); } currentIndex.Fields.AddRange(structureFullTextIndex.Fields .Select(f => new { fieldInfo.DeclaringType.StructureFieldMapping[new Pair <FieldInfo>(fieldInfo, structureTypeInfo.Fields[f.Name])].Name, f.IsAnalyzed, f.Configuration, f.TypeFieldName }) .Select(g => new FullTextFieldDef(g.Name, g.IsAnalyzed) { Configuration = g.Configuration, TypeFieldName = g.TypeFieldName })); } } if (fieldInfo.IsPrimitive) { fieldInfo.DefaultValue = fieldDef.DefaultValue; fieldInfo.DefaultSqlExpression = fieldDef.DefaultSqlExpression; fieldInfo.Column = BuildDeclaredColumn(fieldInfo); if (fieldDef.IsTypeDiscriminator) { type.Hierarchy.TypeDiscriminatorMap.Field = fieldInfo; } } return(fieldInfo); }
public static void WriteOperand(ITextOutput writer, object operand, MethodDef method = null) { Instruction targetInstruction = operand as Instruction; if (targetInstruction != null) { WriteOffsetReference(writer, targetInstruction, method); return; } IList <Instruction> targetInstructions = operand as IList <Instruction>; if (targetInstructions != null) { WriteLabelList(writer, targetInstructions, method); return; } Local variable = operand as Local; if (variable != null) { if (string.IsNullOrEmpty(variable.Name)) { writer.WriteReference(variable.Index.ToString(), variable, TextTokenKind.Number); } else { writer.WriteReference(Escape(variable.Name), variable, TextTokenKind.Local); } return; } Parameter paramRef = operand as Parameter; if (paramRef != null) { if (string.IsNullOrEmpty(paramRef.Name)) { if (paramRef.IsHiddenThisParameter) { writer.WriteReference("<hidden-this>", paramRef, TextTokenKind.Parameter); } else { writer.WriteReference(paramRef.MethodSigIndex.ToString(), paramRef, TextTokenKind.Parameter); } } else { writer.WriteReference(Escape(paramRef.Name), paramRef, TextTokenKind.Parameter); } return; } MemberRef memberRef = operand as MemberRef; if (memberRef != null) { if (memberRef.IsMethodRef) { memberRef.WriteMethodTo(writer); } else { memberRef.WriteFieldTo(writer); } return; } MethodDef methodDef = operand as MethodDef; if (methodDef != null) { methodDef.WriteMethodTo(writer); return; } FieldDef fieldDef = operand as FieldDef; if (fieldDef != null) { fieldDef.WriteFieldTo(writer); return; } ITypeDefOrRef typeRef = operand as ITypeDefOrRef; if (typeRef != null) { typeRef.WriteTo(writer, ILNameSyntax.TypeName); return; } IMethod m = operand as IMethod; if (m != null) { m.WriteMethodTo(writer); return; } MethodSig sig = operand as MethodSig; if (sig != null) { sig.WriteTo(writer); return; } string s = operand as string; if (s != null) { writer.Write("\"" + NRefactory.CSharp.TextWriterTokenWriter.ConvertString(s) + "\"", TextTokenKind.String); } else if (operand is char) { writer.Write(((int)(char)operand).ToString(), TextTokenKind.Number); } else if (operand is float) { float val = (float)operand; if (val == 0) { if (1 / val == float.NegativeInfinity) { // negative zero is a special case writer.Write("-0.0", TextTokenKind.Number); } else { writer.Write("0.0", TextTokenKind.Number); } } else if (float.IsInfinity(val) || float.IsNaN(val)) { byte[] data = BitConverter.GetBytes(val); writer.Write("(", TextTokenKind.Operator); for (int i = 0; i < data.Length; i++) { if (i > 0) { writer.WriteSpace(); } writer.Write(data[i].ToString("X2"), TextTokenKind.Number); } writer.Write(")", TextTokenKind.Operator); } else { writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture), TextTokenKind.Number); } } else if (operand is double) { double val = (double)operand; if (val == 0) { if (1 / val == double.NegativeInfinity) { // negative zero is a special case writer.Write("-0.0", TextTokenKind.Number); } else { writer.Write("0.0", TextTokenKind.Number); } } else if (double.IsInfinity(val) || double.IsNaN(val)) { byte[] data = BitConverter.GetBytes(val); writer.Write("(", TextTokenKind.Operator); for (int i = 0; i < data.Length; i++) { if (i > 0) { writer.WriteSpace(); } writer.Write(data[i].ToString("X2"), TextTokenKind.Number); } writer.Write(")", TextTokenKind.Operator); } else { writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture), TextTokenKind.Number); } } else if (operand is bool) { writer.Write((bool)operand ? "true" : "false", TextTokenKind.Keyword); } else { s = ToInvariantCultureString(operand); writer.Write(s, TextTokenKindUtils.GetTextTokenType(operand)); } }
void HandleInstanceFieldInitializers(IEnumerable <AstNode> members) { var instanceCtors = members.OfType <ConstructorDeclaration>().Where(c => (c.Modifiers & Modifiers.Static) == 0).ToArray(); var instanceCtorsNotChainingWithThis = instanceCtors.Where(ctor => !thisCallPattern.IsMatch(ctor.Body.Statements.FirstOrDefault())).ToArray(); if (instanceCtorsNotChainingWithThis.Length > 0) { MethodDef ctorMethodDef = instanceCtorsNotChainingWithThis[0].Annotation <MethodDef>(); if (ctorMethodDef != null && DnlibExtensions.IsValueType(ctorMethodDef.DeclaringType)) { return; } // Recognize field initializers: // Convert first statement in all ctors (if all ctors have the same statement) into a field initializer. bool allSame; do { Match m = fieldInitializerPattern.Match(instanceCtorsNotChainingWithThis[0].Body.FirstOrDefault()); if (!m.Success) { break; } FieldDef fieldDef = m.Get <AstNode>("fieldAccess").Single().Annotation <IField>().ResolveFieldWithinSameModule(); if (fieldDef == null) { break; } AstNode fieldOrEventDecl = members.FirstOrDefault(f => f.Annotation <FieldDef>() == fieldDef); if (fieldOrEventDecl == null) { break; } Expression initializer = m.Get <Expression>("initializer").Single(); // 'this'/'base' cannot be used in field initializers if (initializer.DescendantsAndSelf.Any(n => n is ThisReferenceExpression || n is BaseReferenceExpression)) { break; } allSame = true; for (int i = 1; i < instanceCtorsNotChainingWithThis.Length; i++) { if (!instanceCtors[0].Body.First().IsMatch(instanceCtorsNotChainingWithThis[i].Body.FirstOrDefault())) { allSame = false; break; } } if (allSame) { var ctorIlRanges = new List <Tuple <MemberMapping, List <ILRange> > >(instanceCtorsNotChainingWithThis.Length); for (int i = 0; i < instanceCtorsNotChainingWithThis.Length; i++) { var ctor = instanceCtorsNotChainingWithThis[i]; var stmt = ctor.Body.First(); stmt.Remove(); var mm = ctor.Annotation <MemberMapping>() ?? ctor.Body.Annotation <MemberMapping>(); Debug.Assert(mm != null); if (mm != null) { ctorIlRanges.Add(Tuple.Create(mm, stmt.GetAllRecursiveILRanges())); } } var varInit = fieldOrEventDecl.GetChildrenByRole(Roles.Variable).Single(); initializer.Remove(); initializer.RemoveAllILRangesRecursive(); varInit.Initializer = initializer; fieldOrEventDecl.AddAnnotation(ctorIlRanges); } } while (allSame); } }
/// <summary> /// Is this a temporary variable generated by the C# compiler for instance method calls on value type values /// </summary> /// <param name="next">The next top-level expression</param> /// <param name="parent">The direct parent of the load within 'next'</param> /// <param name="pos">Index of the load within 'parent'</param> /// <param name="v">The variable being inlined.</param> /// <param name="inlinedExpression">The expression being inlined</param> bool IsGeneratedValueTypeTemporary(ILExpression next, ILExpression parent, int pos, ILVariable v, ILExpression inlinedExpression) { if (pos == 0 && v.Type != null && DnlibExtensions.IsValueType(v.Type)) { // Inlining a value type variable is allowed only if the resulting code will maintain the semantics // that the method is operating on a copy. // Thus, we have to disallow inlining of other locals, fields, array elements, dereferenced pointers switch (inlinedExpression.Code) { case ILCode.Ldloc: case ILCode.Stloc: case ILCode.CompoundAssignment: case ILCode.Ldelem: case ILCode.Ldelem_I: case ILCode.Ldelem_I1: case ILCode.Ldelem_I2: case ILCode.Ldelem_I4: case ILCode.Ldelem_I8: case ILCode.Ldelem_R4: case ILCode.Ldelem_R8: case ILCode.Ldelem_Ref: case ILCode.Ldelem_U1: case ILCode.Ldelem_U2: case ILCode.Ldelem_U4: case ILCode.Ldobj: case ILCode.Ldind_Ref: return(false); case ILCode.Ldfld: case ILCode.Stfld: case ILCode.Ldsfld: case ILCode.Stsfld: // allow inlining field access only if it's a readonly field FieldDef f = ((IField)inlinedExpression.Operand).Resolve(); if (!(f != null && f.IsInitOnly)) { return(false); } break; case ILCode.Call: case ILCode.CallGetter: // inlining runs both before and after IntroducePropertyAccessInstructions, // so we have to handle both 'call' and 'callgetter' IMethod mr = (IMethod)inlinedExpression.Operand; // ensure that it's not an multi-dimensional array getter TypeSig ts; if (mr.DeclaringType is TypeSpec && (ts = ((TypeSpec)mr.DeclaringType).TypeSig.RemovePinnedAndModifiers()) != null && ts.IsSingleOrMultiDimensionalArray) { return(false); } goto case ILCode.Callvirt; case ILCode.Callvirt: case ILCode.CallvirtGetter: // don't inline foreach loop variables: mr = (IMethod)inlinedExpression.Operand; if (mr.Name == "get_Current" && mr.MethodSig != null && mr.MethodSig.HasThis) { return(false); } break; case ILCode.Castclass: case ILCode.Unbox_Any: // These are valid, but might occur as part of a foreach loop variable. ILExpression arg = inlinedExpression.Arguments[0]; if (arg.Code == ILCode.CallGetter || arg.Code == ILCode.CallvirtGetter || arg.Code == ILCode.Call || arg.Code == ILCode.Callvirt) { mr = (IMethod)arg.Operand; if (mr.Name == "get_Current" && mr.MethodSig != null && mr.MethodSig.HasThis) { return(false); // looks like a foreach loop variable, so don't inline it } } break; } // inline the compiler-generated variable that are used when accessing a member on a value type: switch (parent.Code) { case ILCode.Call: case ILCode.CallGetter: case ILCode.CallSetter: case ILCode.Callvirt: case ILCode.CallvirtGetter: case ILCode.CallvirtSetter: IMethod mr = parent.Operand as IMethod; return(mr == null || mr.MethodSig == null ? false : mr.MethodSig.HasThis); case ILCode.Stfld: case ILCode.Ldfld: case ILCode.Ldflda: case ILCode.Await: return(true); } } return(false); }
public ModelInfo(FieldDef field) { OwnerType = field.DeclaringType; FieldIndex = OwnerType.Fields.IndexOf(field); Debug.Assert(FieldIndex >= 0); }
/// <summary> /// Copies the information from the origin field to injected field. /// </summary> /// <param name="fieldDef">The origin FieldDef.</param> /// <param name="ctx">The injection context.</param> static void CopyFieldDef(FieldDef fieldDef, InjectContext ctx) { var newFieldDef = (FieldDef)ctx.Map[fieldDef]; newFieldDef.Signature = ctx.Importer.Import(fieldDef.Signature); }
public virtual void Decompile(FieldDef field, IDecompilerOutput output, DecompilationContext ctx) => this.WriteCommentLine(output, TypeToString(field.DeclaringType, true) + "." + field.Name);
/// <inheritdoc/> public override uint GetRid(FieldDef fd) { uint rid; if (fieldDefInfos.TryGetRid(fd, out rid)) return rid; if (fd == null) Error("Field is null"); else Error("Field {0} ({1:X8}) is not defined in this module ({2})", fd, fd.MDToken.Raw, module); return 0; }
public IFieldNode Create(FieldDef field) => Context.DocumentTreeView.Create(field);
public FieldInfo field(FieldDef field) { return memberInfos.field(field); }
void Analyze(NameService service, ConfuserContext context, ProtectionParameters parameters, FieldDef field) { if (field.DeclaringType.IsVisibleOutside() && (field.IsFamily || field.IsFamilyOrAssembly || field.IsPublic) && !parameters.GetParameter(context, field, "renPublic", false)) { service.SetCanRename(field, false); } else if (field.IsRuntimeSpecialName || field.IsSpecialName) { service.SetCanRename(field, false); } else if (parameters.GetParameter(context, field, "forceRen", false)) { return; } else if (field.DeclaringType.IsSerializable && !field.IsNotSerialized) { service.SetCanRename(field, false); } else if (field.IsLiteral && field.DeclaringType.IsEnum) { service.SetCanRename(field, false); } }
/// <summary> /// Заполнить таблицу dataTable из файла или потока /// </summary> public void Fill(DataTable dataTable, bool allowNulls) { if (dataTable == null) throw new ArgumentNullException("dataTable"); Stream stream = null; BinaryReader reader = null; try { stream = ioStream == null ? new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite) : ioStream; reader = new BinaryReader(stream); // считывание заголовка byte fieldCnt = reader.ReadByte(); // количество полей stream.Seek(2, SeekOrigin.Current); if (fieldCnt > 0) { // считывание определений полей FieldDef[] fieldDefs = new FieldDef[fieldCnt]; int recSize = 2; // размер строки в файле byte[] buf = new byte[FieldDefSize]; for (int i = 0; i < fieldCnt; i++) { // загрузка данных определения поля в буфер для увеличения скорости работы int readSize = reader.Read(buf, 0, FieldDefSize); // заполение определения поля из буфера if (readSize == FieldDefSize) { FieldDef fieldDef = new FieldDef(); fieldDef.DataType = buf[0]; fieldDef.DataSize = BitConverter.ToUInt16(buf, 1); fieldDef.AllowNull = buf[3] > 0; fieldDef.Name = (string)BytesToObj(buf, 4, DataTypes.String); if (string.IsNullOrEmpty(fieldDef.Name)) throw new Exception("Field name can't be empty."); fieldDefs[i] = fieldDef; recSize += fieldDef.DataSize; if (fieldDef.AllowNull) recSize++; } } // формирование структуры таблицы dataTable.BeginLoadData(); dataTable.DefaultView.Sort = ""; if (dataTable.Columns.Count == 0) { foreach (FieldDef fieldDef in fieldDefs) { DataColumn column = new DataColumn(fieldDef.Name); column.AllowDBNull = fieldDef.AllowNull; switch (fieldDef.DataType) { case DataTypes.Integer: column.DataType = typeof(int); break; case DataTypes.Double: column.DataType = typeof(double); break; case DataTypes.Boolean: column.DataType = typeof(bool); break; case DataTypes.DateTime: column.DataType = typeof(DateTime); break; default: column.DataType = typeof(string); column.MaxLength = fieldDef.DataSize - 2; break; } dataTable.Columns.Add(column); } dataTable.DefaultView.AllowNew = false; dataTable.DefaultView.AllowEdit = false; dataTable.DefaultView.AllowDelete = false; } else { dataTable.Rows.Clear(); } // считывание строк buf = new byte[recSize]; while (stream.Position < stream.Length) { // загрузка данных строки таблицы в буфер для увеличения скорости работы int readSize = reader.Read(buf, 0, recSize); // заполение строки таблицы из буфера if (readSize == recSize) { DataRow row = dataTable.NewRow(); int bufInd = 2; foreach (FieldDef fieldDef in fieldDefs) { bool isNull = fieldDef.AllowNull ? buf[bufInd++] > 0 : false; int colInd = dataTable.Columns.IndexOf(fieldDef.Name); if (colInd >= 0) row[colInd] = allowNulls && isNull ? DBNull.Value : BytesToObj(buf, bufInd, fieldDef.DataType); bufInd += fieldDef.DataSize; } dataTable.Rows.Add(row); } } } } catch (EndOfStreamException) { // нормальная ситуация окончания файла } finally { if (fileMode) { if (reader != null) reader.Close(); if (stream != null) stream.Close(); } dataTable.EndLoadData(); dataTable.AcceptChanges(); if (dataTable.Columns.Count > 0) dataTable.DefaultView.Sort = dataTable.Columns[0].ColumnName; } }
public void Analyze(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def) { var method = def as MethodDef; if (method == null || !method.HasBody) { return; } // When a ldtoken instruction reference a definition, // most likely it would be used in reflection and thus probably should not be renamed. // Also, when ToString is invoked on enum, // the enum should not be renamed. for (int i = 0; i < method.Body.Instructions.Count; i++) { Instruction instr = method.Body.Instructions[i]; if (instr.OpCode.Code == Code.Ldtoken) { if (instr.Operand is MemberRef) { IMemberForwarded member = ((MemberRef)instr.Operand).ResolveThrow(); if (context.Modules.Contains((ModuleDefMD)member.Module)) { service.SetCanRename(member, false); } } else if (instr.Operand is IField) { FieldDef field = ((IField)instr.Operand).ResolveThrow(); if (context.Modules.Contains((ModuleDefMD)field.Module)) { service.SetCanRename(field, false); } } else if (instr.Operand is IMethod) { var im = (IMethod)instr.Operand; if (!im.IsArrayAccessors()) { MethodDef m = im.ResolveThrow(); if (context.Modules.Contains((ModuleDefMD)m.Module)) { service.SetCanRename(method, false); } } } else if (instr.Operand is ITypeDefOrRef) { if (!(instr.Operand is TypeSpec)) { TypeDef type = ((ITypeDefOrRef)instr.Operand).ResolveTypeDefThrow(); if (context.Modules.Contains((ModuleDefMD)type.Module) && HandleTypeOf(context, service, method, i)) { var t = type; do { DisableRename(service, t, false); t = t.DeclaringType; } while (t != null); } } } else { throw new UnreachableException(); } } else if ((instr.OpCode.Code == Code.Call || instr.OpCode.Code == Code.Callvirt) && ((IMethod)instr.Operand).Name == "ToString") { HandleEnum(context, service, method, i); } else if (instr.OpCode.Code == Code.Ldstr) { TypeDef typeDef = method.Module.FindReflection((string)instr.Operand); if (typeDef != null) { service.AddReference(typeDef, new StringTypeReference(instr, typeDef)); } } } }
protected void AddReferenced (string signature, FieldDef field, Location location) { FieldTableItem item = new FieldTableItem (field, location); table[signature] = item; }
/// <summary> /// Copies the information from the origin field to injected field. /// </summary> /// <param name="fieldDef">The origin FieldDef.</param> /// <param name="ctx">The injection context.</param> static void CopyFieldDef(FieldDef fieldDef, InjectContext ctx) { var newFieldDef = ctx.Map(fieldDef).ResolveFieldDefThrow(); newFieldDef.Signature = ctx.Importer.Import(fieldDef.Signature); }
protected void AddDefined (string signature, FieldDef field, Location location) { if (table.Contains (signature)) return; FieldTableItem item = new FieldTableItem (field, location); item.Defined = true; table[signature] = item; }
private Schema(Type tdoc) { lock (s_TypeLatch) { if (s_TypeLatch.Contains(tdoc)) { throw new DataException(StringConsts.CRUD_TYPED_DOC_RECURSIVE_FIELD_DEFINITION_ERROR.Args(tdoc.FullName)); } s_TypeLatch.Add(tdoc); try { m_Name = tdoc.AssemblyQualifiedName; var tattrs = tdoc.GetCustomAttributes(typeof(SchemaAttribute), false).Cast <SchemaAttribute>(); tattrs.ForEach(a => a.StopPropAssignmentTracking()); m_SchemaAttrs = new List <SchemaAttribute>(tattrs); //20191026 DKh. Expand resource references in Descriptions m_SchemaAttrs.ForEach(a => { a.ExpandResourceReferencesRelativeTo(tdoc, null); a.Seal(); }); m_FieldDefs = new OrderedRegistry <FieldDef>(); var props = GetFieldMembers(tdoc); var order = 0; foreach (var prop in props) { var fattrs = prop.GetCustomAttributes(typeof(FieldAttribute), false) .Cast <FieldAttribute>() .ToArray(); fattrs.ForEach(a => a.StopPropAssignmentTracking()); //Interpret [Field(CloneFromType)] for (var i = 0; i < fattrs.Length; i++) { var attr = fattrs[i]; if (attr.CloneFromDocType == null) { //20190831 DKh. Expand resource references in Descriptions attr.ExpandResourceReferencesRelativeTo(tdoc, prop.Name); continue; } if (fattrs.Length > 1) { throw new DataException(StringConsts.CRUD_TYPED_DOC_SINGLE_CLONED_FIELD_ERROR.Args(tdoc.FullName, prop.Name)); } var clonedSchema = Schema.GetForTypedDoc(attr.CloneFromDocType); var clonedDef = clonedSchema[prop.Name]; if (clonedDef == null) { throw new DataException(StringConsts.CRUD_TYPED_DOC_CLONED_FIELD_NOTEXISTS_ERROR.Args(tdoc.FullName, prop.Name)); } fattrs = clonedDef.Attrs.ToArray();//replace these attrs from the cloned target break; } FieldAttribute.FixupInheritedTargets($"{tdoc.Name}.{prop.Name}", fattrs); var fdef = new FieldDef(prop.Name, order, prop.PropertyType, fattrs, prop); m_FieldDefs.Register(fdef); order++; } s_TypedRegistry.Register(this); m_TypedDocType = tdoc; } finally { s_TypeLatch.Remove(tdoc); } }//lock }
public void AddFieldDef (FieldDef fielddef) { if (current_field_native_type != null) { fielddef.AddMarshalInfo (current_field_native_type); current_field_native_type = null; } if (current_typedef != null) { current_typedef.AddFieldDef (fielddef); } else { global_field_table.Add ( new DictionaryEntry (fielddef.Name, fielddef.Type.FullName), fielddef); } }
public FieldInfo field(FieldDef field) { return allFieldInfos[field]; }