Ejemplo n.º 1
0
 /// <summary>
 /// Check to see whether there's variable-sized construct in an array. These include arrayVariable, arrayStreamed, union, string.
 /// </summary>
 /// <remarks>
 /// This check should apply to the following scenarios:
 /// <list>
 /// Arrays contain arrayVariable, arrayStreamed, or union
 /// Arrays contain struct which contains any of the above three elements
 /// Arrays contain a number of embedded structs at least one of which contains any of the above three elements
 /// Arrays contain arrayFixed which contains one of the above as element
 /// Arrays contain a number of embedded arrayFixed any of which contains any of the above three elements
 /// </list>
 /// </remarks>
 /// <param name="node"></param>
 /// <param name="report"></param>
 private static void checkVariableConstruct(AbstractNode node, ArrayList report)
 {
     if (node.GetType().Equals(typeof(StructNode)))
     {
         foreach (AbstractNode aNode in ((StructNode)node).getMembers())
         {
             if (aNode.isComplex())
             {
                 checkVariableConstruct(aNode, report);
             }
         }
     }
     else if (node.GetType().Equals(typeof(UnionNode)))
     {
         report.Add("Warning: BinX library version 1.x does not support arrays containing union [" + node.toNodeText() + "].");
     }
     else if (node.GetType().Equals(typeof(ArrayNode)))
     {
         ArrayNode aNode = (ArrayNode)node;
         if (aNode.isArrayFixed() == false)
         {
             report.Add("Warning: BinX library version 1.x does not support arrays containing variable-sized arrays [" + aNode.toNodeText() + "].");
         }
         else
         {
             checkVariableConstruct(aNode.getElement(), report);
         }
     }
 }
Ejemplo n.º 2
0
        /// <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();
            }
        }
Ejemplo n.º 3
0
 /// <summary>
 /// Add an array data element.
 /// </summary>
 /// <param name="parentNode">parent node that contains this new node</param>
 /// <param name="at">position before which the new node is inserted</param>
 public void addArrayTypeNode(DataNode parentNode, int at, bool defineType)
 {
     FormArray formArray = new FormArray();
     if (!defineType)
     {
         formArray.Text = "Build an array element";
         formArray.ChangeLabel("Var Name:");
         formArray.TypeName = "myArray-" + Convert.ToString(parentNode.Nodes.Count);	//TODO: check for duplicate names
     }
     else
     {
         formArray.TypeName = "MyArray-" + Convert.ToString(++typeArrayCounter_);
     }
     formArray.DataTypeSource = document_.getTypeNames();
     DialogResult r = formArray.ShowDialog(view_);
     if (r == DialogResult.OK)
     {
         string varName = formArray.TypeName;
         string arrayType = formArray.ArrayTypeName;
         ArrayNode an = new ArrayNode(arrayType, (defineType)?"":varName);
         //if variable, add sizeRef
         if (formArray.ArrayType == 2)
         {
             AbstractNode data = new PrimitiveNode(formArray.SizeRef);
             an.setSizeRef( data );
         }
         AbstractNode aNode = an;
         if (defineType)
         {
             aNode = new DefineTypeNode(formArray.TypeName, an);
         }
         DataNode dn = new DataNode(aNode);
         addChildNode(dn, formArray.DataType, "");	//element data type as first child node of array
         if (formArray.ArrayType == 3) //arrayStreamed containing only one dim
         {
             //an.addDimension("", 0);
             addChildNode(dn, new DataNode(new DimNode("", 0)), 1);	//dim as second child node of array
         }
         else	//fixed or variable
         {
             DataNode tmpNode = dn;
             foreach (ListViewItem itm in formArray.getDimensions())
             {
                 string scount = itm.Text;
                 string sdimname = itm.SubItems[1].Text;
                 if (!scount.Equals(""))
                 {
                     //DataNode dNode = new DataNode(an.addDimension(sdimname, scount));
                     DataNode dNode = new DataNode(new DimNode(sdimname, scount));
                     addChildNode(tmpNode, dNode, 1);
                     tmpNode = dNode;
                 }
             }
         }
         addChildNode(parentNode, dn, at);
         document_.setModified();
         parentNode.ExpandAll();
     }
 }
Ejemplo n.º 4
0
 /// <summary>
 /// Parse and load an array element type
 /// </summary>
 /// <param name="reader"></param>
 /// <returns></returns>
 protected static ArrayNode LoadArray(XmlTextReader reader)
 {
     string aname = reader.LocalName;
     string vname = reader.GetAttribute("varName");
     string blocksize = reader.GetAttribute("blockSize");
     ArrayNode a = new ArrayNode(aname);
     if (vname != null)
     {
         a.setVarName( vname );
     }
     if (blocksize != null)
     {
         a.setBlockSize( Convert.ToInt32(blocksize) );
     }
     bool inSizeRefSection = false;
     while (reader.Read())
     {
         if (reader.NodeType == XmlNodeType.Element)
         {
             if (reader.LocalName.Equals("sizeRef"))
             {
                 inSizeRefSection = true;
             }
             else if (reader.LocalName.Equals("dim"))
             {
                 string dname = reader.GetAttribute("name");
                 int nCount = 0;
                 string indexTo = reader.GetAttribute("indexTo");
                 if (indexTo == null)
                 {
                     string count = reader.GetAttribute("count");
                     if (count != null)
                     {
                         nCount = Convert.ToInt32(count);
                     }
                 }
                 else
                 {
                     nCount = Convert.ToInt32(indexTo) + 1;
                 }
                 a.addDimension(dname, nCount);
             }
             else if (inSizeRefSection)
             {
                 a.setSizeRef( ParseNode(reader) );
             }
             else
             {
                 a.setElement( ParseNode(reader) );
             }
         }
         else if (reader.NodeType == XmlNodeType.EndElement)
         {
             if (reader.LocalName.Equals("sizeRef"))
             {
                 inSizeRefSection = false;
             }
             else if (reader.LocalName.StartsWith("array"))
             {
                 break;
             }
         }
     }
     return a;
 }
Ejemplo n.º 5
0
 /// <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();
     }
 }
Ejemplo n.º 6
0
 /// <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);
     }
 }
Ejemplo n.º 7
0
        /// <summary>
        /// Parse and load an array element type
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        protected static ArrayNode LoadArray(XmlTextReader reader)
        {
            string    aname     = reader.LocalName;
            string    vname     = reader.GetAttribute("varName");
            string    blocksize = reader.GetAttribute("blockSize");
            ArrayNode a         = new ArrayNode(aname);

            if (vname != null)
            {
                a.setVarName(vname);
            }
            if (blocksize != null)
            {
                a.setBlockSize(Convert.ToInt32(blocksize));
            }
            bool inSizeRefSection = false;

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    if (reader.LocalName.Equals("sizeRef"))
                    {
                        inSizeRefSection = true;
                    }
                    else if (reader.LocalName.Equals("dim"))
                    {
                        string dname   = reader.GetAttribute("name");
                        int    nCount  = 0;
                        string indexTo = reader.GetAttribute("indexTo");
                        if (indexTo == null)
                        {
                            string count = reader.GetAttribute("count");
                            if (count != null)
                            {
                                nCount = Convert.ToInt32(count);
                            }
                        }
                        else
                        {
                            nCount = Convert.ToInt32(indexTo) + 1;
                        }
                        a.addDimension(dname, nCount);
                    }
                    else if (inSizeRefSection)
                    {
                        a.setSizeRef(ParseNode(reader));
                    }
                    else
                    {
                        a.setElement(ParseNode(reader));
                    }
                }
                else if (reader.NodeType == XmlNodeType.EndElement)
                {
                    if (reader.LocalName.Equals("sizeRef"))
                    {
                        inSizeRefSection = false;
                    }
                    else if (reader.LocalName.StartsWith("array"))
                    {
                        break;
                    }
                }
            }
            return(a);
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Add an array data element.
        /// </summary>
        /// <param name="parentNode">parent node that contains this new node</param>
        /// <param name="at">position before which the new node is inserted</param>
        public void addArrayTypeNode(DataNode parentNode, int at, bool defineType)
        {
            FormArray formArray = new FormArray();

            if (!defineType)
            {
                formArray.Text = "Build an array element";
                formArray.ChangeLabel("Var Name:");
                formArray.TypeName = "myArray-" + Convert.ToString(parentNode.Nodes.Count);                     //TODO: check for duplicate names
            }
            else
            {
                formArray.TypeName = "MyArray-" + Convert.ToString(++typeArrayCounter_);
            }
            formArray.DataTypeSource = document_.getTypeNames();
            DialogResult r = formArray.ShowDialog(view_);

            if (r == DialogResult.OK)
            {
                string    varName   = formArray.TypeName;
                string    arrayType = formArray.ArrayTypeName;
                ArrayNode an        = new ArrayNode(arrayType, (defineType)?"":varName);
                //if variable, add sizeRef
                if (formArray.ArrayType == 2)
                {
                    AbstractNode data = new PrimitiveNode(formArray.SizeRef);
                    an.setSizeRef(data);
                }
                AbstractNode aNode = an;
                if (defineType)
                {
                    aNode = new DefineTypeNode(formArray.TypeName, an);
                }
                DataNode dn = new DataNode(aNode);
                addChildNode(dn, formArray.DataType, "");     //element data type as first child node of array
                if (formArray.ArrayType == 3)                 //arrayStreamed containing only one dim
                {
                    //an.addDimension("", 0);
                    addChildNode(dn, new DataNode(new DimNode("", 0)), 1); //dim as second child node of array
                }
                else                                                       //fixed or variable
                {
                    DataNode tmpNode = dn;
                    foreach (ListViewItem itm in formArray.getDimensions())
                    {
                        string scount   = itm.Text;
                        string sdimname = itm.SubItems[1].Text;
                        if (!scount.Equals(""))
                        {
                            //DataNode dNode = new DataNode(an.addDimension(sdimname, scount));
                            DataNode dNode = new DataNode(new DimNode(sdimname, scount));
                            addChildNode(tmpNode, dNode, 1);
                            tmpNode = dNode;
                        }
                    }
                }
                addChildNode(parentNode, dn, at);
                document_.setModified();
                parentNode.ExpandAll();
            }
        }