Given a declaration

const
   topDataQword= 29;
   topNameChar= 231;
type
   Tfnord= record
             case boolean of
               false: (data: array[0..topDataQword] of qword);
               true:  (name: array[0..topNameChar] of char;
                       inode: qword)     (* For recovery if name is
changed      *)
           end;

is it possible to enforce a rule that the two record variants must be the same size?

Mark Morgan Lloyd wrote

is it possible to enforce a rule that the two record variants must be the same size?

No.

Jonas

if same size is necessary, I would do it like this:

const
  topDataQword= 29;
  topNameChar= 231;
type
  Tfnord1 = array[0..topDataQword] of qword ;
  Tfnord2 = record
                       name: array[0..topNameChar] of char;
                       inode: qword
                     end ;
  Tfnord= record
             case boolean of
               false: (data: Tfnord1);
               true:  (ni : Tfnord2)
           end;
and, in the code:
  if sizeof(tfnord1)  sizeof(tfnord2) then halt(4711);

or, in the data
type xxxxxxtest = array [ 1..ord(sizeof(tfnord1) = sizeof(tfnord2)) ] of boolean ;

On Sun, August 7, 2016 18:11, Mark Morgan Lloyd wrote:

Hello Mark,

What would the rule supposedly do? As far as I know, all the variants take the size of the largest one technically (in memory). Do you mean that the compiler should warn if their declared size differs?

Tomas

I assume, my response was a bit unclear. If you code it like this, you should get a runtime-error or compiler-error if the two variants are not same-sized, and I assume, this is what you wanted.

Noting obviously Jonas's and Gerhard's comments.

I was wondering whether the compiler could warn if it found that it had to insert padding since one or other of the variants didn't reach the end of the overall record, the size of which is obviously determined by the largest variant. Obviously, as Gerhard points out, there's ways round it, and I've already got a number of mandatory size checks (i.e. not just assertions) to catch things that smell unusual.

Area of application in this case is laying out a file structure to support a mainframe emulator, where the guest filesystem has no consistency checks so as much as possible needs to be done by the host. However similar requirements also apply wherever a data structure needs to overlay an existing file format or structure in memory.