Custom struct parsing depending on previously read value

[MathiasLui]

hey ho, i love this so far, have been playing around with it

I got some issue, though, which I've been trying to fix for an hour, if someone knows an answer to that...

we have a struct which calculates some offsets and depending on that, the struct may or may not start with a specific field. I finally have something that runs without errors but it doesn't show up in the hex or tree view.

(I tried it with global variables or a function that returns the right struct, setting a Size field but it didn't work)

I'm on my phone so from what I recall it looks like:

struct MyStruct<auto Size> {
    if (Size == 8) {
        MY_ENUM bleh = MYENUM::DEFAULT_VALUE; // have a default value that's not part of the file itself
    }
    else {
        MY_ENUM bleh; //read from bytes instead
        // more fields
    }
};

// some previous logic here
s32 mySize = offset1 - offset2;
MyStruct<mySize> myStruct @32;

it runs, variables have the right values, even the breakpoint hits like it should, but the bytes in the hex view stay default and nothing shows.

I'll try more later or tomorrow, unless I'm on the right track and I'm missing something 🤔

Have a great day :)

[paxcut]

By assigning a value to the variable you are turning it into a local variable which by default will not be shown in the pattern data view and as you rightly implied there is no place in the hex view where it would go. To have it shown in the pattern data tree view use the [[export]] attribute.

[paxcut]

In your example the offset was set to the size of the previous struct that was placed, but inside a struct everything is placed right after the previous item so you don't have to specify the address manually. In fact if you use the placement (@) operator inside a struct, you create what's called a calculated pointer which is not exactly the same as a normal member so it is better not to use it unless you have to.

[MathiasLui]

Thanks for the calculated ptr tip

The thing is, "MyOtherStruct" is not mandatory in the structure.

• (most important) if data.Offset is <= sizeof(data), we continue with other stuff and MySecondStruct doesn't exist
• otherwise, extraDataSize is the amount of extra data we have. If it is smaller than 4, the file (or stream, rather) is invalid
  • if extraDataSize is 8, MySecondStruct will have a specific field set to X, that is not part of the file, we have a specific structure
  • if it is not 8, we read out some property and the MySecondStruct has a slightly different structure

I thought I could just use an if to make the struct optional:

MyStruct data @0;

if (data.Offset > sizeof(data)) {
    // We have additional data before the actual payload
    s32 extraDataSize = data.Offset - sizeof(data);
    if (extraDataSize < 4) {
        isDataValid = false; // This is an out-variable
        return;
    }
    
    MyOtherStruct<extraDataSize> mySecondStruct @sizeof(data);
}

isDataValid = true;

[paxcut]

it will be optional if the condition is not met. for example you can write a struct like this

struct S {
    u8 value;
   if (value == 0)
      u8 data;
    else if(value ==1)
      char name[8];
   else
      u32 default;
};

The size of the struct then depends on where you place it but it will only and always have two members. So things in conditional statements are really conditional items themselves and the data after them is read when the next struct element is read.

[paxcut]

you can write the example you wrote as the following pattern:

struct File {
    MyStruct data;
    if (data.Offset > sizeof(data)) {
    // We have additional data before the actual payload
        s32 extraDataSize = data.Offset - sizeof(data);
        if (extraDataSize < 4) {
            sDataValid = false; // This is an out-variable
           // return; //you may not want to use return because that stops the evaluation. use break to simply exit out of the struct.
        } else
            MyOtherStruct<extraDataSize> mySecondStruct;
    }
};
File file@0;
isDataValid = true;

When File is placed it will first read data struct then check its size and compare it to the offset, If the offset is bigger then it will calculate extraDataSIze because offset-size is positive. Then it checks if it is bigger than 4 and if it is not it stops parsing the struct. but if it is then it reads the second struct. if offset is smaller than size then it wont do any of those things, just read the first struct. This saves you from having to keep track of sizes and offsets for all your data.

[MathiasLui]

Thanks a lot! So when I said "maybe I'll have to encompass everything into another struct", it's basically your example, right?

That will probably fix it, as a bit of a workaround, I'll try it later.
I used the return because in that case the whole stream is invalid and the rest doesn't matter

[MathiasLui]

Works perfectly, thank you for your help!