private void ParamRowDuplicate(/*bool newNameAndID*/) { var selectedParamRow = ParamEntryList.SelectedItem as ParamRow; var selectedParam = MainTabs.SelectedItem as PARAMRef; if (selectedParam == null || selectedParamRow == null) { return; } var newParamRow = new ParamRow(); if (false /*newNameAndID*/) { //var nameEntry = new QuickTextEntry(); //nameEntry.Title = "New Param"; //nameEntry.TextBlockPrompt.Text = "Please input the desired" } else { newParamRow.ID = selectedParamRow.ID; newParamRow.Name = selectedParamRow.Name; } newParamRow.SaveDefaultValuesToRawData(selectedParam.Value); newParamRow.LoadValuesFromRawData(selectedParam.Value); foreach (var cell in newParamRow.Cells) { cell.Value = selectedParamRow[cell.Def.Name]; } selectedParam.Value.Entries.Insert(selectedParam.Value.Entries.IndexOf(selectedParamRow), newParamRow); }
private static void ExportParamRowToJson(ParamRow row, string jsonFile) { var sb = new StringBuilder(); sb.AppendLine(row.Name); sb.AppendLine("{"); bool first = true; foreach (var cell in row.Cells) { if (cell.Def.InternalValueType == ParamTypeDef.dummy8 || cell.Def.GuiValueType == ParamTypeDef.dummy8) { continue; } if (first) { first = false; } else { sb.AppendLine(","); } sb.Append($" \"{cell.Def.Name}\": {cell.Value.ToString().ToLower()}"); } sb.AppendLine(); sb.AppendLine("}"); File.WriteAllText(jsonFile, sb.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="RuntimeParameter"/> class. /// </summary> /// <param name="module">The module.</param> /// <param name="param">The param.</param> public RuntimeParameter(IMetadataModule module, ParamRow param) { _module = module; _attributes = param.Flags; _nameIdx = param.NameIdx; _position = param.Sequence; }
private ParameterDefinitionResolver(uint rid, ParamRow row, MetadataSystem metadata, IMethodInfo method, ITypeInfo type) { _rid = rid; _row = row; _metadata = metadata; _method = method; _type = type; }
/// <summary> /// Loads the parameters. /// </summary> /// <param name="method">The method.</param> /// <param name="first">The first.</param> /// <param name="max">The max.</param> private void LoadParameters(RuntimeMethod method, Token first, Token max) { foreach (Token token in first.Upto(max.PreviousRow)) //for (TokenTypes token = first; token < max; token++) { ParamRow paramDef = metadataProvider.ReadParamRow(token); method.Parameters.Add(new RuntimeParameter(GetString(paramDef.NameIdx), paramDef.Sequence, paramDef.Flags)); } }
public override void FromRawData(byte [] buff, int offs, int numRows) { for (int i = numRows; --i >= 0;) { Row row = new ParamRow(this); row.FromRawData(buff, offs); Add(row); offs += ParamRow.LogicalSize; } }
private void ParamEntryList_AddingNewItem(object sender, AddingNewItemEventArgs e) { var row = new ParamRow(); row.Name = "New Entry"; row.ReInitRawData(SelectedParam); row.LoadValuesFromRawData(SelectedParam); row.SaveDefaultValuesToRawData(SelectedParam); e.NewItem = row; }
/// <summary> /// Reads the specified token. /// </summary> /// <param name="token">The token.</param> /// <param name="result">The result.</param> public void Read(TokenTypes token, out ParamRow result) { if ((token & TokenTypes.TableMask) != TokenTypes.Param) { throw new ArgumentException("Invalid token type for ParamRow.", "token"); } using (BinaryReader reader = CreateReaderForToken(token)) { result = new ParamRow((ParameterAttributes)reader.ReadUInt16(), reader.ReadInt16(), ReadIndexValue(reader, IndexType.StringHeap)); } }
public virtual void VisitParamRow(ParamRow row) { }
public ProcessClassParamsRow AddProcessClassParamsRow(ProcessClassRow parentProcessClassRowByProcessClassProcessClassParams, ParamRow parentParamRowByParamProcessClassParams) { ProcessClassParamsRow rowProcessClassParamsRow = ((ProcessClassParamsRow)(this.NewRow())); object[] columnValuesArray = new object[] { null, null, null}; if ((parentProcessClassRowByProcessClassProcessClassParams != null)) { columnValuesArray[1] = parentProcessClassRowByProcessClassProcessClassParams[0]; } if ((parentParamRowByParamProcessClassParams != null)) { columnValuesArray[2] = parentParamRowByParamProcessClassParams[0]; } rowProcessClassParamsRow.ItemArray = columnValuesArray; this.Rows.Add(rowProcessClassParamsRow); return rowProcessClassParamsRow; }
void IMetadataProvider.Read(TokenTypes token, out ParamRow result) { TableHeap theap = (TableHeap)_streams[(int)HeapType.Tables]; theap.Read(token, out result); }
void CompleteMethods() { TypeDefTable tdefTable = m_tableReader.GetTypeDefTable(); if (!m_tHeap.HasTable(MethodTable.RId)) { m_meths = new MethodDefinition [0]; return; } MethodTable methTable = m_tableReader.GetMethodTable(); ParamTable paramTable = m_tableReader.GetParamTable(); if (!m_tHeap.HasTable(ParamTable.RId)) { m_parameters = new ParameterDefinition [0]; } else { m_parameters = new ParameterDefinition [paramTable.Rows.Count]; } for (int i = 0; i < m_typeDefs.Length; i++) { TypeDefinition dec = m_typeDefs [i]; int index = i, next; if (index == tdefTable.Rows.Count - 1) { next = methTable.Rows.Count + 1; } else { next = (int)(tdefTable [index + 1]).MethodList; } for (int j = (int)tdefTable [index].MethodList; j < next; j++) { MethodRow methRow = methTable [j - 1]; MethodDefinition mdef = m_meths [j - 1]; if (mdef.IsConstructor) { dec.Constructors.Add(mdef); } else { dec.Methods.Add(mdef); } GenericContext context = new GenericContext(mdef); MethodDefSig msig = m_sigReader.GetMethodDefSig(methRow.Signature); mdef.HasThis = msig.HasThis; mdef.ExplicitThis = msig.ExplicitThis; mdef.CallingConvention = msig.MethCallConv; int prms; if (j == methTable.Rows.Count) { prms = m_parameters.Length + 1; } else { prms = (int)(methTable [j]).ParamList; } ParameterDefinition retparam = null; //TODO: optimize this ParamRow pRow = null; int start = (int)methRow.ParamList - 1; if (paramTable != null && start < prms - 1) { pRow = paramTable [start]; } if (pRow != null && pRow.Sequence == 0) // ret type { retparam = new ParameterDefinition( m_root.Streams.StringsHeap [pRow.Name], 0, pRow.Flags, null); retparam.Method = mdef; m_parameters [start] = retparam; start++; } for (int k = 0; k < msig.ParamCount; k++) { int pointer = start + k; if (paramTable != null && pointer < prms - 1) { pRow = paramTable [pointer]; } Param psig = msig.Parameters [k]; ParameterDefinition pdef; if (pRow != null) { pdef = BuildParameterDefinition( m_root.Streams.StringsHeap [pRow.Name], pRow.Sequence, pRow.Flags, psig, context); pdef.MetadataToken = MetadataToken.FromMetadataRow(TokenType.Param, pointer); m_parameters [pointer] = pdef; } else { pdef = BuildParameterDefinition( string.Concat("A_", mdef.IsStatic ? k : k + 1), k + 1, (ParamAttributes)0, psig, context); } pdef.Method = mdef; mdef.Parameters.Add(pdef); } mdef.ReturnType = GetMethodReturnType(msig, context); MethodReturnType mrt = mdef.ReturnType as MethodReturnType; mrt.Method = mdef; if (retparam != null) { mrt.Parameter = retparam; mrt.Parameter.ParameterType = mrt.ReturnType; } } } uint eprid = CodeReader.GetRid((int)m_reader.Image.CLIHeader.EntryPointToken); if (eprid > 0 && eprid <= m_meths.Length) { m_module.Assembly.EntryPoint = GetMethodDefAt(eprid); } }
public ParamRowExt(IMetadataProvider metadata, ParamRow row) : base(metadata) { this.row = row; }
public static ParameterDefinition Resolve(uint rid, ParamRow row, MetadataSystem metadata, IMethodInfo method, ITypeInfo type) { var resolver = new ParameterDefinitionResolver(rid, row, metadata, method, type); return(new ParameterDefinition(resolver)); }
public ParamRowChangeEvent(ParamRow row, global::System.Data.DataRowAction action) { this.eventRow = row; this.eventAction = action; }
public LinkParamsRow AddLinkParamsRow(LinkRow parentLinkRowByLinkLinkParams, ParamRow parentParamRowByParamLinkParams) { LinkParamsRow rowLinkParamsRow = ((LinkParamsRow)(this.NewRow())); object[] columnValuesArray = new object[] { null, null, null}; if ((parentLinkRowByLinkLinkParams != null)) { columnValuesArray[1] = parentLinkRowByLinkLinkParams[0]; } if ((parentParamRowByParamLinkParams != null)) { columnValuesArray[2] = parentParamRowByParamLinkParams[0]; } rowLinkParamsRow.ItemArray = columnValuesArray; this.Rows.Add(rowLinkParamsRow); return rowLinkParamsRow; }
public void AddParamRow(ParamRow row) { this.Rows.Add(row); }
public void RemoveParamRow(ParamRow row) { this.Rows.Remove(row); }