void ParseXML_DB(FileInfo path)
{
XmlDocument doc = new XmlDocument();
doc.Load(path.ToString());
XmlNode block_attrs = doc.SelectSingleNode("/Document/SW.Blocks.GlobalDB/AttributeList", XMLUtil.nameSpaces);
if (block_attrs == null)
{
return;
}
XmlNode block_name_node = block_attrs.SelectSingleNode("Name", XMLUtil.nameSpaces);
if (block_name_node == null)
{
throw new XmlException("Missing block name");
}
string block_name = block_name_node.InnerText;
XmlNode static_section = block_attrs.SelectSingleNode("./Interface/if:Sections/if:Section[@Name='Static']", XMLUtil.nameSpaces);
if (static_section == null)
{
throw new XmlException("Missing static section of block");
}
PathComponent parent = new MemberComponent(block_name, new STRUCT());
readStaticSection(static_section, parent);
}
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 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 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 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 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 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);
}
// 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 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;
}
/// <summary>
/// Makes a copy of the path with the indices substitutes
/// </summary>
/// <param name="path">Original path</param>
/// <param name="substituted">Copy of path with new indices</param>
/// <param name="indices">Indices to substitute</param>
/// <returns>Number of indices in path</returns>
protected static int SubstituteIndices(PathComponent path, out PathComponent substituted, IEnumerator <int> indices)
{
PathComponent parent_copy;
int subs_count;
if (path.Parent != null)
{
subs_count = SubstituteIndices(path.Parent, out parent_copy, indices);
}
else
{
parent_copy = null;
subs_count = 0;
}
if (path is IndexComponent)
{
IndexComponent ic = (IndexComponent)path;
IndexComponent copy = new IndexComponent(new int[ic.Indices.Length], ic.Type, parent_copy);
for (int i = 0; i < ic.Indices.Length; i++)
{
if (!indices.MoveNext())
{
break;
}
copy.Indices[i] = indices.Current;
}
subs_count += ic.Indices.Length;
substituted = copy;
return(subs_count);
}
else
{
MemberComponent member = (MemberComponent)path;
substituted = new MemberComponent(member.Name, member.Type, parent_copy);
return(subs_count);
}
}
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 PathComponent ParsePath(string str)
{
int pos = 0;
PathComponent path = null;
string name;
while (pos < str.Length)
{
if (str[pos] == '"')
{
if (pos + 1 >= str.Length)
{
throw new ParseException("Path ends with '\"'");
}
int end = str.IndexOf('"', pos + 1);
if (end == -1)
{
throw new ParseException("No terminating '\"'");
}
name = str.Substring(pos + 1, end - pos - 1);
pos = end + 1;
}
else
{
int start = pos;
pos = str.IndexOfAny(MemberComponent.ESCAPED_CHARS, pos);
if (pos == -1)
{
pos = str.Length;
}
name = str.Substring(start, pos - start);
}
path = new MemberComponent(name, null, path);
if (pos == str.Length)
{
break;
}
if (str[pos] == '[')
{
if (pos + 1 >= str.Length)
{
throw new ParseException("Path ends with '['");
}
int end = str.IndexOf(']', pos + 1);
if (end == -1)
{
throw new ParseException("No terminating ']'");
}
string indices = str.Substring(pos + 1, end - pos - 1);
string[] index_str = indices.Split(',');
path = new IndexComponent(index_str.Select(s => int.Parse(s)).ToArray <int>(), null, path);
pos = end + 1;
}
if (pos == str.Length)
{
break;
}
if (str[pos] != '.')
{
throw new ParseException("Expected '.'");
}
pos++;
}
return(path);
}
