public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "Padding") { return(null); } var padding = DataElement.Generate <Padding>(node); if (node.hasAttr("alignment")) { padding.alignment = node.getAttrInt("alignment"); } if (node.hasAttr("alignedTo")) { string strTo = node.getAttrString("alignedTo"); padding.alignedTo = parent.find(strTo); if (padding.alignedTo == null) { throw new PeachException("Error, unable to resolve alignedTo '" + strTo + "'."); } } context.handleCommonDataElementAttributes(node, padding); context.handleCommonDataElementChildren(node, padding); return(padding); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "Choice") { return(null); } Choice choice = DataElement.Generate <Choice>(node); choice.parent = parent; context.handleCommonDataElementAttributes(node, choice); context.handleCommonDataElementChildren(node, choice); context.handleDataElementContainer(node, choice); // Move children to choiceElements collection foreach (DataElement elem in choice) { choice.choiceElements.Add(elem.name, elem); elem.parent = choice; } choice.Clear(); return(choice); }
public new static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { var array = DataElement.Generate <Array>(node); if (node.hasAttr("minOccurs")) { array.minOccurs = node.getAttrInt("minOccurs"); array.maxOccurs = -1; array.occurs = array.minOccurs; } if (node.hasAttr("maxOccurs")) { array.maxOccurs = node.getAttrInt("maxOccurs"); } if (node.hasAttr("occurs")) { array.occurs = node.getAttrInt("occurs"); } if (node.hasAttr("mutable")) { array.isMutable = node.getAttrBool("mutable"); } return(array); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "Block") { return(null); } Block block = null; if (node.hasAttr("ref")) { string name = node.getAttr("name", null); string refName = node.getAttrString("ref"); DataElement refObj = context.getReference(refName, parent); if (refObj == null) { throw new PeachException("Error, Block {0}could not resolve ref '{1}'. XML:\n{2}".Fmt( name == null ? "" : "'" + name + "' ", refName, node.OuterXml)); } if (!(refObj is Block)) { throw new PeachException("Error, Block {0}resolved ref '{1}' to unsupported element {2}. XML:\n{3}".Fmt( name == null ? "" : "'" + name + "' ", refName, refObj.debugName, node.OuterXml)); } if (string.IsNullOrEmpty(name)) { name = new Block().name; } block = refObj.Clone(name) as Block; block.parent = parent; block.isReference = true; block.referenceName = refName; } else { block = DataElement.Generate <Block>(node); block.parent = parent; } context.handleCommonDataElementAttributes(node, block); context.handleCommonDataElementChildren(node, block); context.handleDataElementContainer(node, block); return(block); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "Blob") { return(null); } var blob = DataElement.Generate <Blob>(node); context.handleCommonDataElementAttributes(node, blob); context.handleCommonDataElementChildren(node, blob); context.handleCommonDataElementValue(node, blob); if (blob.DefaultValue == null) { blob.DefaultValue = new Variant(new BitStream()); } BitwiseStream bs; if (blob.DefaultValue.GetVariantType() == Variant.VariantType.String) { bs = new BitStream(); new BitWriter(bs).WriteString((string)blob.DefaultValue); } else { System.Diagnostics.Debug.Assert(blob.DefaultValue.GetVariantType() == Variant.VariantType.BitStream); bs = (BitwiseStream)blob.DefaultValue; } bs.Seek(0, SeekOrigin.Begin); blob.DefaultValue = new Variant(bs); if (blob.hasLength) { if (bs.LengthBits > blob.lengthAsBits) { throw new PeachException("Error, value of " + blob.debugName + " is longer than specified length."); } if (bs.LengthBits < blob.lengthAsBits) { bs.SetLengthBits(blob.lengthAsBits); } } return(blob); }
public static DataElement PitParser(PitParser context, XmlNode node, Flags parent) { if (node.Name == "Flags") { return(null); } var flag = DataElement.Generate <Flag>(node); int position = node.getAttrInt("position"); int size = node.getAttrInt("size"); if (position < 0 || size < 0 || (position + size) > parent.lengthAsBits) { throw new PeachException("Error, " + flag.debugName + " is placed outside its parent."); } if (parent.LittleEndian) { position = (int)parent.lengthAsBits - size - position; } foreach (Flag other in parent) { if (other.Overlapps(position, size)) { throw new PeachException("Error, " + flag.debugName + " overlapps with " + other.debugName + "."); } } flag.position = position; flag.lengthType = LengthType.Bits; flag.length = size; // The individual flag is always big endian, it is up to the flags container // to change the order after all the flags are packed. flag.LittleEndian = false; context.handleCommonDataElementAttributes(node, flag); context.handleCommonDataElementChildren(node, flag); context.handleCommonDataElementValue(node, flag); return(flag); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "XmlAttribute" || !(parent is XmlElement)) { return(null); } var xmlAttribute = DataElement.Generate <XmlAttribute>(node); xmlAttribute.attributeName = node.getAttrString("attributeName"); if (node.hasAttr("ns")) { xmlAttribute.ns = node.getAttrString("ns"); } context.handleCommonDataElementAttributes(node, xmlAttribute); context.handleCommonDataElementChildren(node, xmlAttribute); context.handleDataElementContainer(node, xmlAttribute); return(xmlAttribute); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "Blob") { return(null); } var blob = DataElement.Generate <Blob>(node); context.handleCommonDataElementAttributes(node, blob); context.handleCommonDataElementChildren(node, blob); context.handleCommonDataElementValue(node, blob); if (blob.DefaultValue == null) { blob.DefaultValue = new Variant(new byte[0]); } if (blob.DefaultValue.GetVariantType() == Variant.VariantType.String) { blob.DefaultValue = new Variant(ASCIIEncoding.ASCII.GetBytes((string)blob.DefaultValue)); } if (blob.hasLength) { BitStream bs = (BitStream)blob.DefaultValue; if (bs.LengthBits > blob.lengthAsBits) { throw new PeachException("Error, value of " + blob.debugName + " is longer than specified length."); } else if (bs.LengthBits < blob.lengthAsBits) { ExpandDefaultValue(blob, bs); } } return(blob); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "Flags") { return(null); } var flags = DataElement.Generate <Flags>(node); string strSize = null; if (node.hasAttr("size")) { strSize = node.getAttrString("size"); } if (strSize == null) { strSize = context.getDefaultAttr(typeof(Flags), "size", null); } if (strSize == null) { throw new PeachException("Error, Flags elements must have 'size' attribute!"); } int size; if (!int.TryParse(strSize, out size)) { throw new PeachException("Error, " + flags.name + " size attribute is not valid number."); } if (size < 1 || size > 64) { throw new PeachException(string.Format("Error, unsupported size '{0}' for {1}.", size, flags.debugName)); } flags.lengthType = LengthType.Bits; flags.length = size; string strEndian = null; if (node.hasAttr("endian")) { strEndian = node.getAttrString("endian"); } if (strEndian == null) { strEndian = context.getDefaultAttr(typeof(Flags), "endian", null); } if (strEndian != null) { switch (strEndian.ToLower()) { case "little": flags.LittleEndian = true; break; case "big": flags.LittleEndian = false; break; case "network": flags.LittleEndian = false; break; default: throw new PeachException( string.Format("Error, unsupported value '{0}' for 'endian' attribute on {1}.", strEndian, flags.debugName)); } } context.handleCommonDataElementAttributes(node, flags); context.handleCommonDataElementChildren(node, flags); foreach (XmlNode child in node.ChildNodes) { // Looking for "Flag" element if (child.Name == "Flag") { flags.Add(Flag.PitParser(context, child, flags)); } } return(flags); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "String") { return(null); } var str = DataElement.Generate <String>(node); if (node.hasAttr("nullTerminated")) { str.nullTerminated = node.getAttrBool("nullTerminated"); } else { str.nullTerminated = context.getDefaultAttr(typeof(String), "nullTerminated", str.nullTerminated); } string type = "ascii"; if (node.hasAttr("type")) { type = node.getAttrString("type"); } else { type = context.getDefaultAttr(typeof(String), "type", type); } StringType stringType; if (!Enum.TryParse <StringType>(type, true, out stringType)) { throw new PeachException("Error, unknown String type '" + type + "' on element '" + str.name + "'."); } str.stringType = stringType; if (node.hasAttr("padCharacter")) { str.padCharacter = node.getAttrChar("padCharacter"); } else { str.padCharacter = context.getDefaultAttr(typeof(String), "padCharacter", str.padCharacter); } if (node.hasAttr("tokens")) // This item has a default! { throw new NotSupportedException("Tokens attribute is depricated in Peach 3. Use parameter to StringToken analyzer isntead."); } if (node.hasAttr("analyzer")) // this should be passed via a child element me things! { throw new NotSupportedException("Analyzer attribute is depricated in Peach 3. Use a child element instead."); } context.handleCommonDataElementAttributes(node, str); context.handleCommonDataElementChildren(node, str); context.handleCommonDataElementValue(node, str); if (!node.hasAttr("value")) { str.DefaultValue = new Variant(""); } return(str); }
public static DataElement PitParser(PitParser context, XmlNode node, DataElementContainer parent) { if (node.Name != "Number") { return(null); } var num = DataElement.Generate <Number>(node); if (node.hasAttr("signed")) { num.Signed = node.getAttrBool("signed"); } else { num.Signed = context.getDefaultAttr(typeof(Number), "signed", num.Signed); } if (node.hasAttr("size")) { int size = node.getAttrInt("size"); if (size < 1 || size > 64) { throw new PeachException(string.Format("Error, unsupported size '{0}' for {1}.", size, num.debugName)); } num.lengthType = LengthType.Bits; num.length = size; } string strEndian = null; if (node.hasAttr("endian")) { strEndian = node.getAttrString("endian"); } if (strEndian == null) { strEndian = context.getDefaultAttr(typeof(Number), "endian", null); } if (strEndian != null) { switch (strEndian.ToLower()) { case "little": num.LittleEndian = true; break; case "big": num.LittleEndian = false; break; case "network": num.LittleEndian = false; break; default: throw new PeachException( string.Format("Error, unsupported value '{0}' for 'endian' attribute on {1}.", strEndian, num.debugName)); } } context.handleCommonDataElementAttributes(node, num); context.handleCommonDataElementChildren(node, num); context.handleCommonDataElementValue(node, num); return(num); }