public void AddPaths()
{
SINT mtype = SINT.Type;
PresetDB db = new PresetDB("Preset", new IntegerLiteral(7));
STRUCT type = new STRUCT();
ARRAY subtype = new ARRAY()
{
MemberType = new STRING()
{
Capacity = new IntegerLiteral(6)
}
};
subtype.Limits.Add(new ArrayLimits(new IntegerLiteral(-4), new IntegerLiteral(7)));
type.Members.Add(new StructMember()
{
Name = "Int", MemberType = UINT.Type
});
type.Members.Add(new StructMember()
{
Name = "Array", MemberType = subtype
});
PathComponent path = new MemberComponent("Foo", type);
db.AddPath(path, new MultilingualText("en-US", "Comment"), "89");
}
public void RGO_Array_test()
{
RGOBase.ClearAll();
RGOBase T = null;
ARRAY <double> farr1 = new ARRAY <double>(5, "10100", 10, "test description");
ARRAY <double> farr2 = new ARRAY <double>(5, "10101", 10, "test description");
for (int i = 0; i < 10; i++)
{
farr1[i] = 1 / 10.0;
}
for (int i = 0; i < 10; i++)
{
farr2[i] = 1 / 20.0;
}
for (int i = 0; i < 10; i++)
{
Assert.AreNotEqual(farr1[i], farr2[i]);
}
T = farr1;
T.CopyValues(farr2);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual((T as ARRAY <double>)[i], farr2[i]);
}
}
private static IEnumerable<int> Sets(Random rnd, ARRAY test)
{
for (var i = 0; i <= 32; i++)
{
var x = rnd.Next();
yield return test.set(x);
Debug.Assert(test.get(x));
}
}
protected override void DoWork()
{
lock (portal)
{
try
{
TagTable table = folder.TagTables.Find(tableName);
if (table != null)
{
XmlDocument table_doc = TIAutils.ExportHMITagTableXML(table);
HMITagTable editor = new HMITagTable(table_doc);
PathComponent enable_selected = new MemberComponent("EnableSelected", new STRUCT(), new MemberComponent(hmiDbName, new STRUCT()));
PathComponent preset_selected = new MemberComponent("PresetSelected", new STRUCT(), new MemberComponent(hmiDbName, new STRUCT()));
int index = 1;
foreach (var tag in tags)
{
editor.AddIndexedTag("PresetEnable_" + groupName + "_", index, tag.tagPath.PrependPath(enable_selected).ToString());
editor.AddIndexedTag("PresetValue_" + groupName + "_", index, tag.tagPath.PrependPath(preset_selected).ToString(), tag.tagPath.Type);
index++;
}
ARRAY name_array = new ARRAY();
name_array.MemberType = new STRING();
PathComponent preset_names = new MemberComponent("Names", name_array, new MemberComponent(dbName, new STRUCT()));
ARRAY color_array = new ARRAY();
color_array.MemberType = INT.Type;
PathComponent preset_colors = new MemberComponent("Colors", color_array, new MemberComponent(dbName, new STRUCT()));
for (int p = 1; p <= nPresets; p++)
{
PathComponent name = new IndexComponent(new int[1] {
p
}, new STRING(), preset_names);
editor.AddIndexedTag("PresetName_" + groupName + "_", p, name.ToString());
PathComponent color = new IndexComponent(new int[1] {
p
}, INT.Type, preset_colors);
editor.AddIndexedTag("PresetColor_" + groupName + "_", p, color.ToString());
}
TIAutils.ImportHMITagTableXML(table_doc, folder);
}
else
{
LogMessage(MessageLog.Severity.Warning, "No tag table named '" + tableName + "' was found, skipping.");
}
}
catch (Exception ex)
{
LogMessage(MessageLog.Severity.Error, "Failed to update tag table:\n" + ex.Message);
return;
}
}
}
public static void SetPresetNames(XmlElement tag_element, ConstantLookup constants, string[] values)
{
ARRAY name_array = new ARRAY
{
MemberType = new STRUCT()
};
MemberComponent name_tag = new MemberComponent("Names", name_array);
SetPathValues(tag_element, name_tag, constants, values);
}
public static void SetPresetValue(XmlElement tag_element, PathComponent path, ConstantLookup constants, object[] values)
{
ARRAY preset_array = new ARRAY
{
MemberType = new STRUCT()
};
MemberComponent preset_tag = new MemberComponent("Preset", preset_array);
PathComponent value_path = path.PrependPath(preset_tag);
SetPathValues(tag_element, value_path, constants, values);
}
public static object[] GetPresetValue(XmlElement tag_element, PathComponent path, ConstantLookup constants)
{
ARRAY preset_array = new ARRAY
{
MemberType = new STRUCT()
};
MemberComponent preset_tag = new MemberComponent("Preset", preset_array);
PathComponent value_path = path.PrependPath(preset_tag);
Array array = GetPathValues(tag_element, value_path, constants);
return(FlattenArray <object>(array));
}
public static void SetPresetColors(XmlElement tag_element, ConstantLookup constants, int[] values)
{
ARRAY name_array = new ARRAY
{
MemberType = new STRUCT()
};
MemberComponent name_tag = new MemberComponent("Colors", name_array);
var objs = values.Select <int, object>(x => (object)x).ToArray <object>();
SetPathValues(tag_element, name_tag, constants, objs);
}
public static void SetPresetEnabled(XmlElement tag_element, PathComponent path, ConstantLookup constants, bool?[] values)
{
ARRAY enable_array = new ARRAY
{
MemberType = new STRUCT()
};
MemberComponent enable_tag = new MemberComponent("Enable", enable_array);
PathComponent value_path = path.PrependPath(enable_tag);
object [] obj_values = values.Select(x => (object)x).ToArray();
SetPathValues(tag_element, value_path, constants, obj_values);
}
public static bool?[] GetPresetEnabled(XmlElement tag_element, PathComponent path, ConstantLookup constants)
{
ARRAY enable_array = new ARRAY
{
MemberType = new STRUCT()
};
MemberComponent enable_tag = new MemberComponent("Enable", enable_array);
PathComponent value_path = path.PrependPath(enable_tag);
Array array = GetPathValues(tag_element, value_path, constants);
return(FlattenArray <bool?>(array));
}
public static int[] GetPresetColors(XmlElement tag_element, ConstantLookup constants)
{
ARRAY name_array = new ARRAY();
MemberComponent name_tag = new MemberComponent("Colors", name_array);
Array array = GetPathValues(tag_element, name_tag, constants);
if (array.Rank != 1)
{
throw new Exception("Names tag must be one dimensional");
}
return(FlattenArray <int>(array));
}
public static PathComponent InitializeArrayPath(PathComponent path, ConstantLookup constants)
{
PathComponent parent;
if (path.Parent != null)
{
parent = InitializeArrayPath(path.Parent, constants);
}
else
{
parent = null;
}
if (path is IndexComponent)
{
IndexComponent index = (IndexComponent)path;
int[] indices = new int[index.Indices.Count()];
for (int i = 0; i < indices.Count(); i++)
{
indices[i] = ((IntegerLiteral)((ARRAY)parent.Type).Limits[i].LowLimit).Value;
}
path = new IndexComponent(indices, index.Type, parent);
}
else
{
MemberComponent member = (MemberComponent)path;
DataType type = member.Type;
ARRAY array_type = path.Type as ARRAY;
if (array_type != null)
{
ARRAY new_array_type = new ARRAY();
new_array_type.MemberType = array_type.MemberType;
new_array_type.Limits = new ArrayLimits[array_type.Limits.Count];
for (int i = 0; i < new_array_type.Limits.Count(); i++)
{
new_array_type.Limits[i] = new ArrayLimits(
new IntegerLiteral(array_type.Limits[i].LowLimit.ResolveInt(constants)),
new IntegerLiteral(array_type.Limits[i].HighLimit.ResolveInt(constants)));
}
type = new_array_type;
}
path = new MemberComponent(member.Name, type, parent);
}
return(path);
}
static void Main(string[] args)
{
var test = new ARRAY(1);
var reference = new HashSet<int>();
var rnd = new Random();
reference.Add(1);
var ops = 0;
foreach (var o in Sets(rnd, test))
{
ops += o;
Console.WriteLine($"{test.SetCount}: {o}, total {ops}, merges so far {ARRAY.MergeCount}");
}
}
public void RGO_GetValueAsString()
{
RGOBase.ClearAll();
AI analogIn1 = new AI(1, "10100", IOCategory.Real, "test description");
analogIn1.RawValue = 5.555;
ARRAY <double> farr1 = new ARRAY <double>(5, "10101", 10, "test description");
for (int i = 0; i < 10; i++)
{
farr1[i] = 1 / 10.0;
}
SV <double> sv1 = new SV <double>(1, "10102", "TestDescription");
sv1.Value = 3.333;
SV <string> sv2 = new SV <string>(1, "10103", "TestDescription");
sv2.Value = "Hello, this is an SV";
EQP <double> eqp1 = new EQP <double>(5, "10104", "TestSubSys", "testParName", 10.5, 5, 15, Units.mA, "Test description");
RGOBase T = analogIn1;
Assert.AreEqual(analogIn1.Value.ToString(), T.GetValueAsString(3));
Assert.AreNotEqual(analogIn1.Value.ToString(), T.GetValueAsString(2));
Assert.AreEqual(analogIn1.Value.ToString(), T.GetValueAsString());
T = eqp1;
Assert.AreEqual(eqp1.Value.ToString(), T.GetValueAsString(1));
Assert.AreEqual(eqp1.Value.ToString(), T.GetValueAsString());
T = sv1;
Assert.AreEqual(sv1.Value.ToString(), T.GetValueAsString());
T = sv2;
Assert.AreEqual(sv2.Value.ToString(), T.GetValueAsString());
Assert.AreNotEqual(sv2.Value.ToString(), T.GetValueAsString(3));
T = farr1;
Assert.AreNotEqual(farr1[3], T.GetValueAsString());
}
// Substitute all indices in path with th low limit of the corresponding array
protected PathComponent SubstituteIndicesLow(PathComponent path)
{
PathComponent parent_copy;
if (path.Parent != null)
{
parent_copy = SubstituteIndicesLow(path.Parent);
}
else
{
parent_copy = null;
}
if (path is IndexComponent)
{
IndexComponent ic = (IndexComponent)path;
int[] indices = new int[ic.Indices.Length];
if (!(ic.Parent is MemberComponent && ic.Parent.Type is ARRAY))
{
throw new Exception("Parent of index component is not an array");
}
ARRAY array_type = (ARRAY)ic.Parent.Type;
for (int l = 0; l < array_type.Limits.Count; l++)
{
Constant low = array_type.Limits[l].LowLimit;
if (!(low is IntegerLiteral))
{
throw new Exception("Low limity of array is not an integer constant.");
}
int low_limit = ((IntegerLiteral)low).Value;
indices[l] = low_limit;
}
return(new IndexComponent(indices, ic.Type, parent_copy));
}
else
{
MemberComponent member = (MemberComponent)path;
return(new MemberComponent(member.Name, member.Type, parent_copy));
}
}
public override string ToString()
{
g = (ARRAY)base.Tag;
Binding myBinding = new Binding("variables");
myBinding.Mode = BindingMode.TwoWay;
myBinding.Source = g;
txtvars.SetBinding(TextBox.TextProperty, myBinding);
Binding myBinding2 = new Binding("values");
myBinding2.Mode = BindingMode.TwoWay;
myBinding2.Source = g;
txtvals.SetBinding(TextBox.TextProperty, myBinding2);
Binding descbinding = new Binding("Description");
descbinding.Mode = BindingMode.TwoWay;
descbinding.Source = g;
txtdesc.SetBinding(TextBox.TextProperty, descbinding);
return base.ToString();
}
public PresetDB(string block_name, Constant array_length, XmlDocument doc = null)
{
has_remanence_attr = true;
if (doc == null)
{
doc = new XmlDocument();
doc.LoadXml(Resources.InitialPresetDB);
}
this.doc = doc;
static_section =
(XmlElement)doc.SelectSingleNode("/Document/SW.Blocks.GlobalDB/AttributeList/Interface/if:Sections/if:Section[@Name='Static']", nsmgr);
if (static_section == null)
{
throw new Exception("No section named 'Static' in XML");
}
ARRAY array_type = new ARRAY();
array_type.Limits.Add(new ArrayLimits(new IntegerLiteral(1), array_length));
array_type.MemberType = new STRUCT();
int[] preset_index = new int[1] {
1
};
PathComponent preset_member = new MemberComponent("Preset", array_type);
preset_prefix = new IndexComponent(preset_index, array_type.MemberType, preset_member);
PathComponent enable_member = new MemberComponent("Enable", array_type);
enable_prefix = new IndexComponent(preset_index, array_type.MemberType, enable_member);
enable_selected_prefix = new MemberComponent("EnableSelected", new STRUCT());
preset_selected_prefix = new MemberComponent("PresetSelected", new STRUCT());
XmlElement name_elem =
(XmlElement)doc.SelectSingleNode("/Document/SW.Blocks.GlobalDB/AttributeList/Name", nsmgr);
name_elem.InnerText = block_name;
}
public override string ToString()
{
g = (ARRAY)base.Tag;
Binding myBinding = new Binding("variables");
myBinding.Mode = BindingMode.TwoWay;
myBinding.Source = g;
txtvars.SetBinding(TextBox.TextProperty, myBinding);
Binding myBinding2 = new Binding("values");
myBinding2.Mode = BindingMode.TwoWay;
myBinding2.Source = g;
txtvals.SetBinding(TextBox.TextProperty, myBinding2);
Binding descbinding = new Binding("Description");
descbinding.Mode = BindingMode.TwoWay;
descbinding.Source = g;
txtdesc.SetBinding(TextBox.TextProperty, descbinding);
return(base.ToString());
}
/// <summary>
/// Adds an ARRAY BIFF Record to the arraylist
/// </summary>
/// <param name="array"></param>
//TODO
public void addARRAY(ARRAY array)
{
this.ARRAYList.Add(array);
}
/// <summary>
/// Extracting the data from the stream
/// </summary>
public override void extractData()
{
BiffHeader bh, latestbiff;
BOF firstBOF = null;
//try
//{
while (this.StreamReader.BaseStream.Position < this.StreamReader.BaseStream.Length)
{
bh.id = (RecordType)this.StreamReader.ReadUInt16();
bh.length = this.StreamReader.ReadUInt16();
// TraceLogger.DebugInternal("BIFF {0}\t{1}\t", bh.id, bh.length);
Console.WriteLine("WORKSHEET-BIFF {0}\t{1}\t", bh.id, bh.length);
switch (bh.id)
{
case RecordType.EOF:
{
this.StreamReader.BaseStream.Seek(0, SeekOrigin.End);
}
break;
case RecordType.BOF:
{
var bof = new BOF(this.StreamReader, bh.id, bh.length);
switch (bof.docType)
{
case BOF.DocumentType.WorkbookGlobals:
case BOF.DocumentType.Worksheet:
firstBOF = bof;
break;
case BOF.DocumentType.Chart:
// parse chart
break;
default:
this.readUnknownFile();
break;
}
}
break;
case RecordType.LabelSst:
{
var labelsst = new LabelSst(this.StreamReader, bh.id, bh.length);
this.bsd.addLabelSST(labelsst);
}
break;
case RecordType.MulRk:
{
var mulrk = new MulRk(this.StreamReader, bh.id, bh.length);
this.bsd.addMULRK(mulrk);
}
break;
case RecordType.Number:
{
var number = new Number(this.StreamReader, bh.id, bh.length);
this.bsd.addNUMBER(number);
}
break;
case RecordType.RK:
{
var rk = new RK(this.StreamReader, bh.id, bh.length);
this.bsd.addRK(rk);
}
break;
case RecordType.MergeCells:
{
var mergecells = new MergeCells(this.StreamReader, bh.id, bh.length);
this.bsd.MERGECELLSData = mergecells;
}
break;
case RecordType.Blank:
{
var blankcell = new Blank(this.StreamReader, bh.id, bh.length);
this.bsd.addBLANK(blankcell);
} break;
case RecordType.MulBlank:
{
var mulblank = new MulBlank(this.StreamReader, bh.id, bh.length);
this.bsd.addMULBLANK(mulblank);
}
break;
case RecordType.Formula:
{
var formula = new Formula(this.StreamReader, bh.id, bh.length);
this.bsd.addFORMULA(formula);
TraceLogger.DebugInternal(formula.ToString());
}
break;
case RecordType.Array:
{
var array = new ARRAY(this.StreamReader, bh.id, bh.length);
this.bsd.addARRAY(array);
}
break;
case RecordType.ShrFmla:
{
var shrfmla = new ShrFmla(this.StreamReader, bh.id, bh.length);
this.bsd.addSharedFormula(shrfmla);
}
break;
case RecordType.String:
{
var formulaString = new STRING(this.StreamReader, bh.id, bh.length);
this.bsd.addFormulaString(formulaString.value);
}
break;
case RecordType.Row:
{
var row = new Row(this.StreamReader, bh.id, bh.length);
this.bsd.addRowData(row);
}
break;
case RecordType.ColInfo:
{
var colinfo = new ColInfo(this.StreamReader, bh.id, bh.length);
this.bsd.addColData(colinfo);
}
break;
case RecordType.DefColWidth:
{
var defcolwidth = new DefColWidth(this.StreamReader, bh.id, bh.length);
this.bsd.addDefaultColWidth(defcolwidth.cchdefColWidth);
}
break;
case RecordType.DefaultRowHeight:
{
var defrowheigth = new DefaultRowHeight(this.StreamReader, bh.id, bh.length);
this.bsd.addDefaultRowData(defrowheigth);
}
break;
case RecordType.LeftMargin:
{
var leftm = new LeftMargin(this.StreamReader, bh.id, bh.length);
this.bsd.leftMargin = leftm.value;
}
break;
case RecordType.RightMargin:
{
var rightm = new RightMargin(this.StreamReader, bh.id, bh.length);
this.bsd.rightMargin = rightm.value;
}
break;
case RecordType.TopMargin:
{
var topm = new TopMargin(this.StreamReader, bh.id, bh.length);
this.bsd.topMargin = topm.value;
}
break;
case RecordType.BottomMargin:
{
var bottomm = new BottomMargin(this.StreamReader, bh.id, bh.length);
this.bsd.bottomMargin = bottomm.value;
}
break;
case RecordType.Setup:
{
var setup = new Setup(this.StreamReader, bh.id, bh.length);
this.bsd.addSetupData(setup);
}
break;
case RecordType.HLink:
{
long oldStreamPos = this.StreamReader.BaseStream.Position;
try
{
var hlink = new HLink(this.StreamReader, bh.id, bh.length);
this.bsd.addHyperLinkData(hlink);
}
catch (Exception ex)
{
this.StreamReader.BaseStream.Seek(oldStreamPos, System.IO.SeekOrigin.Begin);
this.StreamReader.BaseStream.Seek(bh.length, System.IO.SeekOrigin.Current);
TraceLogger.Debug("Link parse error");
TraceLogger.Error(ex.StackTrace);
}
}
break;
case RecordType.MsoDrawing:
{
// Record header has already been read. Reset position to record beginning.
this.StreamReader.BaseStream.Position -= 2 * sizeof(ushort);
this.bsd.ObjectsSequence = new ObjectsSequence(this.StreamReader);
}
break;
default:
{
// this else statement is used to read BiffRecords which aren't implemented
var buffer = new byte[bh.length];
buffer = this.StreamReader.ReadBytes(bh.length);
}
break;
}
latestbiff = bh;
}
//}
//catch (Exception ex)
//{
// TraceLogger.Error(ex.Message);
// TraceLogger.Error(ex.StackTrace);
// TraceLogger.Debug(ex.ToString());
//}
}
public TypeReference GetTypeRefFromSig(SigType t, GenericContext context)
{
switch (t.ElementType)
{
case ElementType.Class:
CLASS c = t as CLASS;
return(GetTypeDefOrRef(c.Type, context));
case ElementType.ValueType:
VALUETYPE vt = t as VALUETYPE;
TypeReference vtr = GetTypeDefOrRef(vt.Type, context);
vtr.IsValueType = true;
return(vtr);
case ElementType.String:
return(SearchCoreType(Constants.String));
case ElementType.Object:
return(SearchCoreType(Constants.Object));
case ElementType.Void:
return(SearchCoreType(Constants.Void));
case ElementType.Boolean:
return(SearchCoreType(Constants.Boolean));
case ElementType.Char:
return(SearchCoreType(Constants.Char));
case ElementType.I1:
return(SearchCoreType(Constants.SByte));
case ElementType.U1:
return(SearchCoreType(Constants.Byte));
case ElementType.I2:
return(SearchCoreType(Constants.Int16));
case ElementType.U2:
return(SearchCoreType(Constants.UInt16));
case ElementType.I4:
return(SearchCoreType(Constants.Int32));
case ElementType.U4:
return(SearchCoreType(Constants.UInt32));
case ElementType.I8:
return(SearchCoreType(Constants.Int64));
case ElementType.U8:
return(SearchCoreType(Constants.UInt64));
case ElementType.R4:
return(SearchCoreType(Constants.Single));
case ElementType.R8:
return(SearchCoreType(Constants.Double));
case ElementType.I:
return(SearchCoreType(Constants.IntPtr));
case ElementType.U:
return(SearchCoreType(Constants.UIntPtr));
case ElementType.TypedByRef:
return(SearchCoreType(Constants.TypedReference));
case ElementType.Array:
ARRAY ary = t as ARRAY;
return(new ArrayType(GetTypeRefFromSig(ary.Type, context), ary.Shape));
case ElementType.SzArray:
SZARRAY szary = t as SZARRAY;
ArrayType at = new ArrayType(GetTypeRefFromSig(szary.Type, context));
return(at);
case ElementType.Ptr:
PTR pointer = t as PTR;
if (pointer.Void)
{
return(new PointerType(SearchCoreType(Constants.Void)));
}
return(new PointerType(GetTypeRefFromSig(pointer.PtrType, context)));
case ElementType.FnPtr:
FNPTR funcptr = t as FNPTR;
FunctionPointerType fnptr = new FunctionPointerType(funcptr.Method.HasThis, funcptr.Method.ExplicitThis,
funcptr.Method.MethCallConv, GetMethodReturnType(funcptr.Method, context));
for (int i = 0; i < funcptr.Method.ParamCount; i++)
{
Param p = funcptr.Method.Parameters [i];
fnptr.Parameters.Add(BuildParameterDefinition(
string.Concat("A_", i),
i, (ParamAttributes)0,
p, context));
}
return(fnptr);
case ElementType.Var:
VAR var = t as VAR;
if (context.AllowCreation)
{
CheckGenericParameters(context, var);
}
if (context.Type is GenericInstanceType)
{
return((context.Type as GenericInstanceType).GenericArguments [var.Index]);
}
else
{
return(context.Type.GenericParameters [var.Index]);
}
case ElementType.MVar:
MVAR mvar = t as MVAR;
if (context.Method is GenericInstanceMethod)
{
return((context.Method as GenericInstanceMethod).GenericArguments [mvar.Index]);
}
else
{
return(context.Method.GenericParameters [mvar.Index]);
}
case ElementType.GenericInst:
GENERICINST ginst = t as GENERICINST;
GenericInstanceType instance = new GenericInstanceType(GetTypeDefOrRef(ginst.Type, context));
instance.IsValueType = ginst.ValueType;
for (int i = 0; i < ginst.Signature.Arity; i++)
{
instance.GenericArguments.Add(GetTypeRefFromSig(
ginst.Signature.Types [i], context));
}
return(instance);
default:
break;
}
return(null);
}
protected MemberComponent readMember(XmlElement member_elem, PathComponent parent)
{
string name = member_elem.GetAttribute("Name");
string type_str = member_elem.GetAttribute("Datatype");
string left;
DataType type = DataTypeParser.Parse(type_str, out left);
MemberComponent member = new MemberComponent(name, type, parent);
PathComponent child_path = member;
if (type is ARRAY)
{
ARRAY array = (ARRAY)type;
child_path = new IndexComponent(new int[array.Limits.Count], array.MemberType, member);
if ((options & Options.NoSubelement) != 0)
{
if (member != child_path)
{
handle_tag(new HandleTagEventArgs()
{
Path = SubstituteIndicesLow(child_path),
Comment = null
});
}
}
}
XmlElement comment_elem = member_elem.SelectSingleNode("if:Comment", XMLUtil.nameSpaces) as XmlElement;
MultilingualText comment = null;
if (comment_elem != null)
{
comment = readComment(comment_elem);
}
if (((options & Options.AllowNoComment) != 0) || comment != null)
{
handle_tag(new HandleTagEventArgs()
{
Path = SubstituteIndicesLow(member),
Comment = comment
});
}
XmlNodeList member_elems = member_elem.SelectNodes("if:Member", XMLUtil.nameSpaces);
foreach (XmlNode m in member_elems)
{
MemberComponent submember = readMember((XmlElement)m, child_path);
if (child_path.Type is STRUCT)
{
STRUCT struct_type = (STRUCT)child_path.Type;
struct_type.Members.Add(new StructMember()
{
Name = submember.Name, MemberType = submember.Type
});
}
}
if ((options & Options.NoSubelement) == 0)
{
XmlNodeList sub_elems = member_elem.SelectNodes("if:Subelement", XMLUtil.nameSpaces);
foreach (XmlNode s in sub_elems)
{
readSubelement(s as XmlElement, child_path);
}
}
return(member);
}
public static TypeElement ReadType(SignatureReader rdr)
{
TypeElement ret;
switch (rdr.GetElementTypeAhead())
{
case ElementType.Void:
case ElementType.TypedByRef:
ret = new BaseType(); break;
case ElementType.Boolean:
case ElementType.Char:
case ElementType.Int8:
case ElementType.UInt8:
case ElementType.Int16:
case ElementType.UInt16:
case ElementType.Int32:
case ElementType.UInt32:
case ElementType.Int64:
case ElementType.UInt64:
case ElementType.Single:
case ElementType.Double:
case ElementType.IntPtr:
case ElementType.UIntPtr:
case ElementType.Object:
case ElementType.String:
ret = new BaseType(); break;
case ElementType.Array:
ret = new ARRAY(); break;
case ElementType.Class:
ret = new CLASS(); break;
case ElementType.FnPtr:
ret = new FNPTR(); break;
case ElementType.GenericInstance:
ret = new GENERICINST(); break;
case ElementType.MethodGenericVar:
ret = new MVAR(); break;
case ElementType.Pointer:
ret = new PTR(); break;
case ElementType.SzArray:
ret = new SZARRAY(); break;
case ElementType.ValueType:
ret = new VALUETYPE(); break;
case ElementType.GenericVar:
ret = new VAR(); break;
default:
throw new InvalidOperationException();
}
ret.Read(rdr);
return(ret);
}
