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 virtual void VisitParamRow(ParamRow 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);
}
