/// <summary> /// Add a dim node to array node or another dim node, if one is available, it is replaced. /// </summary> /// <remarks>If parent node is the ArrayNode or DefineTypeNode of ArrayNode, then /// the new DimNode will replace the original DimNode which is then indented (demoted as the grandchild. /// If the parent node is a DimNode, then its child node is replaced and degraded, or if no child node /// exists, the new node is added as the child.</remarks> /// <param name="parentNode"></param> /// <param name="at"></param> public void addDimNode(DataNode parentNode, int at) { AbstractNode dNode = parentNode.getDataNode(); if (dNode.GetType().Equals(typeof(DefineTypeNode))) { dNode = ((DefineTypeNode)dNode).getBaseType(); } FormDim formDim = new FormDim(); DialogResult r = formDim.ShowDialog(view_); if (r == DialogResult.OK) { string sdname = formDim.DimName; string scount = formDim.DimCount; DimNode dimNode = new DimNode(sdname, scount); ((ComplexNode)dNode).insertChild(dimNode, 0); //at irrelevant for array and dim node DataNode d = new DataNode(dimNode); DataNode old = (DataNode)parentNode.LastNode; if (old != null) { parentNode.Nodes.Remove(old); d.Nodes.Add(old); } parentNode.Nodes.Add(d); parentNode.ExpandAll(); } }
/// <summary> /// Add array element to the array node in the treeview from loaded document. /// TODO: no support for array containing arrays or unions /// </summary> /// <param name="node"></param> /// <param name="t"></param> protected void addArrayNode(TreeNode node, ArrayNode t) { DataNode dt = new DataNode(t.getElement()); node.Nodes.Add(dt); if (t.getElement().isComplex()) { ComplexNode ct = (ComplexNode)t.getElement(); if (ct.GetType().Equals(typeof(StructNode))) { addStructNode(node.LastNode, (StructNode)ct); } else if (ct.GetType().Equals(typeof(ArrayNode))) { addArrayNode(node.LastNode, (ArrayNode)ct); } else if (ct.GetType().Equals(typeof(UnionNode))) { addUnionNode(node.LastNode, (UnionNode)ct); } } // add dims DataNode lastNode = (DataNode)node; DimNode dim = t.getDimension(); while (dim != null) { DataNode d = new DataNode(dim); lastNode.Nodes.Add(d); lastNode = d; dim = dim.getChild(); } }
private string name_; //name of dimension #endregion Fields #region Constructors public DimNode(string name, int count) : base("dim") { this.name_ = name; this.count_ = count; this.child_ = null; }
public override void removeChild(int at) { //must be removing the dim child if (dim_ != null) { dim_ = dim_.getChild(); } }
/// <summary> /// Remove the only child node and promote the child's child node. /// </summary> /// <param name="at">ignored here</param> public override void removeChild(int at) { DimNode d = this.child_; if (d != null) { this.child_ = d.getChild(); } }
/// <summary> /// Add a Dimension node to the leaf (lowest child) /// </summary> /// <param name="d"></param> public void addDescendant(DimNode d) { if (child_ != null) { child_.addDescendant(d); } else { child_ = d; } }
/// <summary> /// Add or replace a child DimNode to this one, demote its child if available. /// </summary> /// <remarks>A DimNode can have only one child DimNode node. When this DimNode already has a child DimNode, /// the new child DimNode is set as the only child node and the old child node becomes the child node of the /// added child node (grandchild of this node). Note that if the given child node already has a child node, /// it will be lost in this case.</remarks> /// <param name="child"></param> public override void addChild(AbstractNode child) { if (child.GetType().Equals(typeof(DimNode))) { DimNode c = this.child_; this.child_ = (DimNode)child; if (c != null) { this.child_.setChild(c); } } }
public int getDimensionCount() { int count = 0; DimNode d = dim_; while (d != null) { count++; d = d.getChild(); } return(count); }
/// <summary> /// Add a dimension to the array /// </summary> /// <param name="dname">name of dimension</param> /// <param name="dcount">count of dimension elements</param> public DimNode addDimension(string dname, int dcount) { DimNode d = new DimNode(dname, dcount); if (dim_ == null) { dim_ = d; } else { dim_.addDescendant(d); } return d; }
public DimNode(string name, string scount) : base("dim") { this.name_ = name; try { this.count_ = Convert.ToInt32(scount); } catch (Exception ex) { Console.WriteLine(ex.Message); } this.child_ = null; }
/// <summary> /// Add a dimension to the array /// </summary> /// <param name="dname">name of dimension</param> /// <param name="dcount">count of dimension elements</param> public DimNode addDimension(string dname, int dcount) { DimNode d = new DimNode(dname, dcount); if (dim_ == null) { dim_ = d; } else { dim_.addDescendant(d); } return(d); }
/// <summary> /// Override insertChild to add only element node, dim node won't be added. /// </summary> /// <param name="child"></param> /// <param name="at"></param> public override void insertChild(AbstractNode child, int at) { if (!child.GetType().Equals(typeof(DimNode))) { setElement(child); } else { if (dim_ != null) { ((DimNode)child).setChild(dim_); } dim_ = (DimNode)child; } }
private DimNode child_; //embedded dim public DimNode(string name, int count) : base("dim") { this.name_ = name; this.count_ = count; this.child_ = null; }
public void setChild(DimNode node) { this.child_ = node; }
/// <summary> /// Check struct, union and array node for useType references, duplicate union case values. /// </summary> /// <remarks> /// This check should apply to the following scenarios: /// <list> /// A struct contains two or more member elements that have the same variable name /// A struct contains a useType as its member or member of its member which referenced a undefined type /// A struct contains no member element /// A union contains no case element /// A union contains two or more cases with the same discriminant value /// A union contains a useType element in any of the case elements that referenced a undefined type /// An array contains no dimension element /// An streamed array contains more than one dim element /// An variable-sized array's first dim element has a count (should be zero) /// A fixed array contains a dim element with a zero count (should be greater than 0) /// An array contains useType element that referenced a undefined type /// An array contains a variable-sized construct in its element or embeded descedants. /// </list> /// </remarks> /// <param name="dataNode"></param> /// <param name="defs"></param> /// <param name="report"></param> private static void checkComplexType(ComplexNode dataNode, Hashtable defs, ArrayList report) { if (dataNode.GetType().Equals(typeof(StructNode))) { StructNode sNode = (StructNode)dataNode; if (sNode.getMemberCount() > 0) { Hashtable varNames = new Hashtable(); foreach (AbstractNode aNode in ((StructNode)dataNode).getMembers()) { //check duplicate variable names as warnings checkVarNames(aNode, varNames, report); checkUseType(aNode, defs, report); } } else { //empty struct report.Add("Warning: struct '" + sNode.toNodeText() + "' contains no member element."); } } else if (dataNode.GetType().Equals(typeof(UnionNode))) { UnionNode uNode = (UnionNode)dataNode; if (uNode.getCaseCount() > 0) { Hashtable cases = new Hashtable(); foreach (CaseNode cNode in uNode.getCases()) { //case values must be unique if (cases.Contains(cNode.getDiscriminantValue())) { report.Add("Error: duplicate case value '" + cNode.getDiscriminantValue() + "' at union type '" + dataNode.toNodeText() + "'."); } else { cases.Add(cNode.getDiscriminantValue(), cNode); } //if case body is useType, check type defs checkUseType(cNode.getCaseBody(), defs, report); } } else { report.Add("Warning: union '" + uNode.toNodeText() + "' contains no case element."); } } else if (dataNode.GetType().Equals(typeof(ArrayNode))) { ArrayNode arrayNode = (ArrayNode)dataNode; if (arrayNode.getDimension() == null) { report.Add("Error: Array '" + arrayNode.toNodeText() + "' has no dimension element."); } else { if (arrayNode.isArrayStreamed() && arrayNode.getDimensionCount() > 1) { report.Add("Warning: Streamed array contains more than one dimension."); } else if (arrayNode.isArrayFixed()) { for (DimNode dn = arrayNode.getDimension(); dn != null; dn = dn.getChild()) { if (dn.count() <= 0) { report.Add("Error: array dimension is of invalid size at '" + arrayNode.toNodeText() + "'."); } } } else { //first dim must be of 0 size DimNode dn = arrayNode.getDimension(); if (dn.count() > 0) { report.Add("Warning: first dimension count of a variable-sized array ignored at '" + arrayNode.toNodeText() + "'."); } for (dn = dn.getChild(); dn != null; dn = dn.getChild()) { if (dn.count() <= 0) { report.Add("Error: array dimension is of invalid size at '" + arrayNode.toNodeText() + "'."); } } } } checkUseType(arrayNode.getElement(), defs, report); //check for variable-sized construct contained in arrays checkVariableConstruct(arrayNode.getElement(), report); } }
public void setDimension(DimNode dim) { dim_ = dim; }