public SerializerTypeReference(PdlArrayType lengthType, PdlArrayType arrayType)
: base("Serializer", PdlType.Serializer, arrayType)
{
if (lengthType == null)
{
throw new InvalidOperationException("A Serializer must have an array type");
}
this.lengthType = lengthType;
}
public void CalculateFixedSerializationLength()
{
if (calculatedFixedSerializationLength)
{
throw new InvalidOperationException(
"Cannot calculate FixedSerializationLength after it has already been calculated");
}
UInt32 length = 0;
for (int i = 0; i < fields.Count; i++)
{
ObjectDefinitionField field = fields[i];
TypeReference fieldTypeReference = field.typeReference;
UInt32 fieldFixedSerializationLength = fieldTypeReference.FixedElementSerializationLength;
if (fieldFixedSerializationLength == UInt32.MaxValue)
{
this.fixedSerializationLength = UInt32.MaxValue;
calculatedFixedSerializationLength = true;
return;
}
PdlArrayType arrayType = fieldTypeReference.arrayType;
if (arrayType == null)
{
length += fieldFixedSerializationLength;
}
else
{
if (arrayType.type != PdlArraySizeTypeEnum.Fixed)
{
this.fixedSerializationLength = UInt32.MaxValue;
calculatedFixedSerializationLength = true;
return;
}
length += arrayType.GetFixedArraySize() * fieldFixedSerializationLength;
}
}
this.fixedSerializationLength = length;
calculatedFixedSerializationLength = true;
}
public ObjectTypeReference(String relativeObjectReferenceTypeString, NamedObjectDefinition definition, PdlArrayType arrayType)
: base(relativeObjectReferenceTypeString, PdlType.Object, arrayType)
{
this.relativeObjectReferenceTypeString = relativeObjectReferenceTypeString;
this.definition = definition;
}
public EnumOrFlagsTypeReference(String relativeEnumReferenceTypeString, EnumOrFlagsDefinition definition, PdlArrayType arrayType)
: base(relativeEnumReferenceTypeString, definition.isFlagsDefinition ? PdlType.Flags : PdlType.Enum, arrayType)
{
this.relativeEnumReferenceTypeString = relativeEnumReferenceTypeString;
this.definition = definition;
}
public AsciiTypeReference(String typeString, PdlArrayType arrayType)
: base(typeString, PdlType.Ascii, arrayType)
{
}
public IntegerTypeReference(PdlType integerType, PdlArrayType arrayType)
: base(integerType.ToString(), integerType, arrayType)
{
this.byteCount = integerType.IntegerTypeByteCount();
}
public TypeReference(String relativePdlTypeReferenceString, PdlType type, PdlArrayType arrayType)
{
this.relativePdlTypeReferenceString = relativePdlTypeReferenceString;
this.type = type;
this.arrayType = arrayType;
}
public static void ParseObjectFieldLine(PdlFile pdlFile, LfdReader reader, NamedObjectDefinition containingNamedObject,
IFieldContainer containingObject, LfdLine fieldLine, out LfdLine nextLine)
{
//
// Check if it is only a definition (enum or flag)
//
if (fieldLine.id.Equals("enum", StringComparison.OrdinalIgnoreCase))
{
ParseEnumOrFlagsDefinition(pdlFile, reader, containingNamedObject, fieldLine, out nextLine, false);
return;
}
if (fieldLine.id.Equals("flags", StringComparison.OrdinalIgnoreCase))
{
ParseEnumOrFlagsDefinition(pdlFile, reader, containingNamedObject, fieldLine, out nextLine, true);
return;
}
String typeString = fieldLine.id;
//
// The rest of the fields can have arrayParse the Array Size Type
//
PdlArrayType arrayType;
int indexOfOpenBracket = typeString.IndexOf('[');
if (indexOfOpenBracket < 0)
{
arrayType = null;
}
else
{
String arraySizeTypeString = typeString.Substring(indexOfOpenBracket + 1);
typeString = typeString.Remove(indexOfOpenBracket);
int indexOfCloseBracket = arraySizeTypeString.IndexOf(']');
if (indexOfCloseBracket < 0)
{
throw new ParseException(fieldLine, "Found an opening bracket '[' without a closing bracket");
}
if (indexOfCloseBracket != arraySizeTypeString.Length - 1)
{
throw new ParseException(fieldLine, "The array size type '{0}' had a closing bracket, but the closing bracket was not the last character", arraySizeTypeString);
}
arraySizeTypeString = arraySizeTypeString.Remove(indexOfCloseBracket);
arrayType = PdlArrayType.Parse(fieldLine, arraySizeTypeString);
}
//
// Parse object inline definition
//
if (typeString.Equals("object", StringComparison.OrdinalIgnoreCase))
{
VerifyFieldCount(fieldLine, 1);
String objectDefinitionAndFieldName = fieldLine.fields[0];
NamedObjectDefinition fieldObjectDefinition = ParseObjectDefinition(pdlFile, reader, fieldLine,
containingNamedObject, objectDefinitionAndFieldName, out nextLine);
containingObject.AddField(new ObjectDefinitionField(
new ObjectTypeReference(objectDefinitionAndFieldName, fieldObjectDefinition, arrayType),
objectDefinitionAndFieldName));
return;
}
//
// Check if it is a serializer
//
if (fieldLine.id.Equals("serializer", StringComparison.OrdinalIgnoreCase))
{
VerifyFieldCount(fieldLine, 2);
String serializerLengthTypeString = fieldLine.fields[0];
String serializerFieldName = fieldLine.fields[1];
PdlArrayType serializerLengthType = PdlArrayType.Parse(fieldLine, serializerLengthTypeString);
containingObject.AddField(new ObjectDefinitionField(new SerializerTypeReference(serializerLengthType, arrayType), serializerFieldName));
nextLine = reader.ReadLineIgnoreComments();
return;
}
//
// Check if it is an 'if' type
//
if (typeString.Equals("if", StringComparison.OrdinalIgnoreCase))
{
VerifyFieldCount(fieldLine, 1);
IfTypeReference ifType = ParseIf(pdlFile, reader, fieldLine,
containingNamedObject, out nextLine);
containingObject.AddField(new ObjectDefinitionField(ifType, null));
return;
}
//
// Check if it is a switch type
//
if (typeString.Equals("switch", StringComparison.OrdinalIgnoreCase))
{
VerifyFieldCount(fieldLine, 1);
SwitchTypeReference switchType = ParseSwitch(pdlFile, reader, fieldLine,
containingNamedObject, out nextLine);
containingObject.AddField(new ObjectDefinitionField(switchType, null));
return;
}
//
// The field is only one line, so read the next line now for the caller
//
nextLine = reader.ReadLineIgnoreComments();
EnumOrFlagsDefinition enumDefinition = pdlFile.TryGetEnumOrFlagsDefinition(containingNamedObject, typeString);
if (enumDefinition != null)
{
VerifyFieldCount(fieldLine, 1);
containingObject.AddField(new ObjectDefinitionField(new EnumOrFlagsTypeReference(typeString, enumDefinition, arrayType),
fieldLine.fields[0]));
return;
}
// Check if it is an object type
NamedObjectDefinition objectDefinition = pdlFile.TryGetObjectDefinition(containingNamedObject, typeString);
if (objectDefinition != null)
{
if (fieldLine.fields == null || fieldLine.fields.Length <= 0)
{
//
// Add each field from the object definition to the current object definition
//
List <ObjectDefinitionField> objectDefinitionFields = objectDefinition.Fields;
for (int i = 0; i < objectDefinitionFields.Count; i++)
{
ObjectDefinitionField fieldDefinition = objectDefinitionFields[i];
containingObject.AddField(fieldDefinition);
}
}
else if (fieldLine.fields.Length == 1)
{
containingObject.AddField(new ObjectDefinitionField(
new ObjectTypeReference(typeString, objectDefinition, arrayType), fieldLine.fields[0]));
}
else
{
throw new ParseException(fieldLine, "Expected line to have 0 or 1 fields but had {0}", fieldLine.fields.Length);
}
return;
}
//
// Check if it a string type
//
if (typeString.Equals("ascii", StringComparison.OrdinalIgnoreCase))
{
VerifyFieldCount(fieldLine, 1);
containingObject.AddField(new ObjectDefinitionField(
new AsciiTypeReference(typeString, arrayType), fieldLine.fields[0]));
return;
}
//
// It must be an integer type
//
VerifyFieldCount(fieldLine, 1);
PdlType type;
try { type = (PdlType)Enum.Parse(typeof(PdlType), typeString, true); }
catch (ArgumentException) { throw new FormatException(String.Format("Unknown Pdl Type '{0}'", typeString)); }
if (!type.IsIntegerType())
{
throw new InvalidOperationException(String.Format("Unhandled PDL type '{0}'", type));
}
containingObject.AddField(new ObjectDefinitionField(new IntegerTypeReference(type, arrayType), fieldLine.fields[0]));
}
