Unsized array to EOF

[LeoAdamek]

Some file formats contain header data and then specify to read a data structure until the end of the file is reached.

For example the PNG format contains an 8 byte header, followed by three or more data-chunks which can be of variable type/sizes, which repeat until the end of the file.

So far this is my Pattern:

#pragma endian big

enum ChunkType : u32 {
	// Critical Chunks (uppercase first char)
	ImageHeader = 0x49484452, //"IHDR",
	Palette		= 0x504c5445, //"PLTE",
	ImageData	= 0x49444154, //"IDAT",
	ImageEnd	= 0x49454E44, //"IEND",
	
	// Ancillery chunks (lowercase first char)
	Background	= "bKGD",
	ChromaticityCoords = "cHRM",
	Signature	= "dSIG",
	Exif		= "eXIf",
	Gamma		= "gAMA",
	ColourHist  = "hIST",
	PixelDims   = 0x70485973, //"pHYs"
	Text		= 0x74455874, //"tEXt"
};

enum ColorType : u8 {
	Grayscale = 0,
	RGB		  = 2,
	Indexed	  = 3,
	GrayAlpha = 4,
	RGBA	  = 6
};

enum PixelUnit : u8 {
	Unknown,
	Metres
};


namespace ChunkData {
	struct ImageHeader {
		u32 imageWidth	[[name("Image Width")]];
		u32 imageHeight	[[name("Image Height")]];
		u8	bitsPerPixel	[[name("Bits Per Pixel")]];
		ColorType colorType	[[name("Colour Type")]];
		u8	compression		[[name("Compression Type")]];
		u8	filter			[[name("Filter Type")]];
		bool interlace		[[name("Interlaced Image?")]];
	};
	
	struct ImageData {
		u8 compression;
		u8 fCheck;
		u8 dataBlock[6];
		u32 alder32;
	};
	
	struct PixelPhysicalDimensions {
		u32	x [[name("Width")]];
		u32	y [[name("Height")]];
		PixelUnit unit [[name("Unit")]];
	};
	
	struct PaletteEntry {
		u8 red		[[name("Red"),  color("ff0000ff")]];
		u8 green	[[name("Green"),color("00ff0000")]];
		u8 blue		[[name("Blue"), color("0000ff00")]];
	};
}


struct Header {
	u8 binaryFlag [[comment("Byte with MSB high to avoid 7-bit interpretation"),name("Binary Flag")]];
	char magic[3] [[comment("PNG Magic"), name("File Magic")]];
	char crlf[2]  [[comment("CRLF to detect DOS line endings"), name("CRLF")]];
	char eof	  [[comment("EOF Marker to flag file as binary"), name("EOF")]];
	char lf		  [[comment("LF to detect UNIX line endings"), name("LF")]];
};

struct Chunk {
	u32 length			[[comment("Chunk Length"), color("48006C00")]];
	be ChunkType chunkType	[[comment("Chunk type/name"), color("00566C00")]];

	if (chunkType == ChunkType::ImageHeader) {
		ChunkData::ImageHeader data;
	} else if (chunkType == ChunkType::Palette) {
		ChunkData::PaletteEntry palette[length / 3];
	} else if (chunkType == ChunkType::PixelDims) {
		ChunkData::PixelPhysicalDimensions data;
	} else if (chunkType == ChunkType::Text) {
		char data[length];
	} else {
		u8 data[length];
	}

	u32	crc32 [[comment("Data CRC-32")]];
};

Header header @ 0x00;
Chunk  chunks[NUM_CHUNKS]  @ 0x08;

The issue is that the number of chunks is not stored, chunks are read until the end of the file is reached. Using the unsized array syntax:

Chunk  chunks[] @ 0x08;

Throws an error as there is never a zero chunk. Usually the last chunk has a type of IEND but it is not required to be the final chunk.

How would I express this pattern?

[WerWolv]

Hi!
There's currently no proper function in the standard library sadly but one way to do it is:

Chunk chunks[while($ < std::mem::size())] @ 0x08;

This will keep on creating more entries in the chunks array until the current offset (denoted with $) is not smaller than the size of the currently loaded data anymore.