OpenEuphoria

Introduction

The goal of this feature is to make it easier to use C-like structures in raw memory. This is often required when interfacing euphoria code with outside libraries, or the operating system itself. The proposed changes to euphoria are designed to make this interface easier and less error prone.

Since we're dealing with C-based structures, it makes a certain amount of sense to keep the usage similar to C. C uses the asterisk (*) to dereference pointers and access the pointed to value. This is often confusing, and can be difficult to use, especially when accessing deeply nested structures. This proposal suggests that a better way to dereference a pointer would encompass the entire reference, including all structure elements. This gives a clear indication as to what is happening.

Using C style structures

Atoms will be used to hold pointers to memory locations, just like before, but putting them inside square brackets will dereference the pointer and 'serialize' or 'deserialize' the euphoria objects into raw memory, or vice versa. We could potentially use raw atoms, which would require qualifying the structure being referenced:

    atom my_struct 
    .... 
    [my_struct.rect.x] = 5 
    .... 
    atom x = [my_struct.rect.x] 

Or alternatively, we could use structures like user defined types:

    rect my_struct 
    .... 
    [my_struct.x] = 5 
    .... 
    atom x = [my_struct.x] 

These two styles could coexist.

Initialization could be done using a new function or operator. The function could optionally be a machine function. Of course, this implies that a reference to a structure is a 'first class' object. It's possible that this would need to be converted to a 'structure id' similar to how routine ids are used. The default should probably be to automatically free the memory when the reference count drops to zero. It would be important to allow the possibility of not freeing the memory, since sometimes ownership of the memory passes to a separate library.

The bracket syntax is really just syntactic sugar for the peeks and pokes currently used in euphoria. In fact, the implementation might be to actually emit peek and poke IL.

foo = bar 
[mystruct.x] = qwerty 

foo = bar[mystruct.x] = qwerty 

Declaring structures

A new keyword, 'structure' could be introduced to declare and define memory structures. There would be two primitive type of members, integer and atom, representing ints and floats, respectively, with additional size specifiers. Possibly these could be optional, with sensible defaults:

structure rect 
    integer(32) x 
    integer(32) y 
    atom(64) width 
    atom(64) height 
end structure 

This structure represents a rectangle where the x and y coordinates are represented as 32-bit integers, and the width and height as 64-bit floating point values.

structure qwerty 
    pointer foo -- native pointer  
    pointer(32) bar -- 32-bit pointer. 
end structure 

At least two modifiers will be needed:

structure c_string 
    integer(8) with unsigned, null char[] 
end structure 

This structure defines the standard, null terminated c string, where each character is an 8-bit integer, and the array is null terminated.

In addition, we should be able to embed structures within other structures, either as a pointer, or as a part of the main structure.

structure my_rect 
    c_string [name] 
    rect rect 
end structure 

The above declaration defines a structure with a pointer to a string, and a rect embedded within it. It would be 28 bytes in size, assuming 4-byte pointers.

One other key feature of structures is the union:

structure shape 
    c_string [name] 
    union shape 
        rect r 
        circle c 
    end union 
end structure