Example #1
0
        protected override Field CloneField()
        {
            var f = new IfpBlockField(node);

            foreach (var block in BlockList)
            {
                if (!f.BlockList.Add((Block)block.Clone()))
                {
                    Console.WriteLine("Unable to add block to cloned block field.");
                    break;
                }
            }

            return(f);
        }
Example #2
0
        public IfpTagBlock(IfpNode ifpNode)
        {
            int size;

            if (ifpNode.HeaderSize > ifpNode.TagBlockSize)
            {
                size = ifpNode.HeaderSize;
            }
            else
            {
                size = ifpNode.TagBlockSize;
            }

            AnalyzeFieldSet(ifpNode.Nodes, size);

            int offset = 0, previousOffset = 0;

            if (ifpNode.Alignment > 0)
            {
                alignment = ifpNode.Alignment;
            }

            bool skipId = false;

            foreach (var node in ifpNode.Nodes)
            {
                Field field = null;
                if (node.FieldOffset >= offset)
                {
                    offset = node.FieldOffset;
                }
                else if (node.FieldOffset > 0)
                {
                    continue;
                }

                if (node.Type == IfpNodeType.Tag)
                {
                    int nodeIndex = ifpNode.Nodes.IndexOf(node);
                    if (ifpNode.Nodes.Count > nodeIndex && ifpNode.Nodes[nodeIndex + 1].Type == IfpNodeType.TagId)
                    {
                        skipId = true;
                        continue;
                    }
                }
                else if (node.Type == IfpNodeType.TagId && skipId)
                {
                    skipId = false;
                    field  = new TagReferenceField(node.Name);
                }
                else
                {
                    switch (node.Type)
                    {
                    case IfpNodeType.TagBlock:
                        field = new IfpBlockField(node);
                        break;

                    case IfpNodeType.UnusedArray:
                        field = new PadField(node.Name, node.Length);
                        break;

                    case IfpNodeType.Byte:
                    case IfpNodeType.SignedByte:
                        field = new CharIntegerField(node.Name);
                        break;

                    case IfpNodeType.Short:
                    case IfpNodeType.UnsignedShort:
                        field = new ShortIntegerField(node.Name);
                        break;

                    case IfpNodeType.Int:
                    case IfpNodeType.UnsignedInt:
                        field = new LongIntegerField(node.Name);
                        break;

                    case IfpNodeType.Single:
                        field = new RealField(node.Name);
                        break;

                    case IfpNodeType.Enumerator8:
                        field = new CharEnumField(node.Name);
                        break;

                    case IfpNodeType.Enumerator16:
                        field = new EnumField(node.Name);
                        break;

                    case IfpNodeType.Enumerator32:
                        field = new LongEnumField(node.Name);
                        break;

                    case IfpNodeType.Bitfield8:
                        field = new ByteFlagsField(node.Name);
                        break;

                    case IfpNodeType.Bitfield16:
                        field = new WordFlagsField(node.Name);
                        break;

                    case IfpNodeType.Bitfield32:
                        field = new LongFlagsField(node.Name);
                        break;

                    case IfpNodeType.String32:
                        field = new StringField(node.Name);
                        break;

                    case IfpNodeType.String64:
                        break;

                    case IfpNodeType.Unicode128:
                        break;

                    case IfpNodeType.Unicode256:
                        break;

                    case IfpNodeType.Tag:
                        field = new TagField(node.Name);
                        break;

                    case IfpNodeType.TagId:
                        field = new TagIndexField(node.Name);
                        break;

                    case IfpNodeType.StringId:
                        field = new StringIdField(node.Name);
                        break;
                    }
                }

                if (field != null)
                {
                    if (node.Type == IfpNodeType.Enumerator8 || node.Type == IfpNodeType.Enumerator16 || node.Type == IfpNodeType.Enumerator32 ||
                        node.Type == IfpNodeType.Bitfield8 || node.Type == IfpNodeType.Bitfield16 || node.Type == IfpNodeType.Bitfield32)
                    {
                        var optionField = (OptionField)field;
                        foreach (var optionNode in node.Nodes)
                        {
                            optionField.Options.Add(new Option(optionNode.Name, optionNode.Value));
                        }
                    }

                    if (previousOffset <= offset)
                    {
                        int length = offset - previousOffset;
                        if (length > 0)
                        {
                            Fields.Add(new PadField("ifp padding", length));
                        }

                        offset        += field.Size;
                        previousOffset = offset;
                        Fields.Add(field);
                    }
                }
            }

            if (offset < size)
            {
                Fields.Add(new PadField("ifp padding", size - offset));
            }

            if (!string.IsNullOrEmpty(ifpNode.Label))
            {
                var labelFields = Fields.Where(f => f.Name.Equals(ifpNode.Label, StringComparison.OrdinalIgnoreCase));
                foreach (var labelField in labelFields)
                {
                    this.labelFields.Add(labelField);
                }
            }
        }