feature:support flexible array member

[luoliwoshang]

struct string_descriptor_zero {
    uint8_t bLength;
    uint8_t bDescriptorType;
    uint16_t wBcdLang[];
} __packed;

https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html

[MeteorsLiu]

Investigate

In above example, the size of wBcdLang[] is zero.

To find out the best data structure in Go, i investigate these.

Empty slice

By default, the size of an uninitiated slice is the size of slice struct in runtime, commonly, in x64 platform, whose size is 24.

However, slice cannot meet our requirement because of its memory size.

We expect it zero.

Empty array

The size of a empty array is 0, which meets our memory requirement.

However, it's hard to resize for a zero length array.

In Go, to append data to array, you have to convert it to slice. But this will cause unexpected memory size( cap and len field in slice struct ).

Also, resizing a zero length array will cause changes of memory address .

func main() {
	var s [0]int
	s2 := append(s[:], 111)
	t := unsafe.SliceData(s2)
	fmt.Println(unsafe.Sizeof(s), uintptr(unsafe.Pointer(t)), uintptr(unsafe.Pointer(&s)))
}

CGO

CGO disallows to use zero length field in Go, see https://go-review.googlesource.com/c/go/+/12864

[luoliwoshang]

maybe we can use lots of methods with zero length array in go to mock this behavior

package main

import (
	"fmt"
	"unsafe"
)

// CFlex mimics a C struct with a flexible array member.
type CFlex struct {
	x int64
	y [0]int64
}

// NewCFlex is a constructor that only handles memory allocation.
func NewCFlex(arraySize int) *CFlex {
	// Calculate the total size needed: size of the struct + size for the array elements.
	totalSize := unsafe.Sizeof(CFlex{}) + uintptr(arraySize)*unsafe.Sizeof(int64(0))

	// Allocate a raw block of memory as a byte slice.
	memBlock := make([]byte, totalSize)

	// Cast the pointer to the start of the memory block to a *CFlex pointer.
	return (*CFlex)(unsafe.Pointer(&memBlock[0]))
}

// GetY provides safe access to the elements in the "flexible" array part.
func (c *CFlex) GetY(index int) *int64 {
	// Calculate the address of the i-th element:
	// Start at the address of 'y' and add the offset (index * element_size).
	return (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(&c.y)) + uintptr(index)*unsafe.Sizeof(int64(0))))
}

func main() {
	fmt.Println("--- Method 1: Allocate memory first, then initialize ---")

	// Step 1: Call the constructor, specifying how much "flexible" space is needed.
	ptr := NewCFlex(3)

	// Step 2: Use standard "." syntax to initialize the regular fields.
	ptr.x = 999

	// The "flexible array" part still needs to be assigned using the special method.
	*ptr.GetY(0) = 11
	*ptr.GetY(1) = 22

	// Print the results to verify.
	fmt.Printf("Value of ptr.x: %d\n", ptr.x)
	fmt.Printf("Value of ptr.y[0]: %d\n", *ptr.GetY(0))
	fmt.Printf("Value of ptr.y[1]: %d\n", *ptr.GetY(1))
}