volatile struct definition for peripheral control registers

[Josh Holtrop]

I'm working on an embedded project writing some device drivers to 
access peripheral control registers as MMIO addresses. Due to D's 
lack of a `volatile` keyword, I'm trying to come up with a way to 
define these peripheral control register structures in a way that 
doesn't require the user of the structure to have to remember to 
call `volatileStore()` or `volatileLoad()` for each register 
access separately and I want the interface to be as clean as 
possible.

In C I would have just declared the entire structure to be 
`volatile` since the entire thing lives in MMIO address range, 
and I suppose I'm trying to achieve something close to that...

# Attempt #1

Declare a `Volatile(T)` struct template:

```d
module myproj.volatile;

import core.volatile;

struct Volatile(T)
{
     T v;

     T get()
     {
         return volatileLoad(&v);
     }

     void opAssign(T v)
     {
         volatileStore(&this.v, v);
     }
}
```

Use as:

```d
import myproj.volatile;

struct S
{
     Volatile!uint reg;
     Volatile!uint reg2;
     struct
     {
         Volatile!uint subreg;
     };
}

void vtest()
{
     S * s = cast(S *)0xDEADBEEF;
     while (s.reg.get == 0)
     {
         s.subreg = 1;
     }
}

```

This works but requires that ugly .get call rather than just 
accessing it directly.

# Attempt #2

```d
module myproj.volatile;

public import core.volatile;

template volatile_field(string type, string name)
{
     mixin("private "~type~" v_"~name~";");
     mixin("public @property "~type~" "~name~"() { return 
volatileLoad(&v_"~name~"); }");
     mixin("public @property void "~name~"("~type~" v) { 
volatileStore(&v_"~name~", v); }");
}

template volatile_ubyte(string name)
{
     mixin volatile_field!("ubyte", name);
}

template volatile_ushort(string name)
{
     mixin volatile_field!("ushort", name);
}

template volatile_uint(string name)
{
     mixin volatile_field!("uint", name);
}

template volatile_ulong(string name)
{
     mixin volatile_field!("ulong", name);
}
```

```d
import myproj.volatile;

struct S
{
     mixin volatile_uint!"reg";
     mixin volatile_uint!"reg2";
     struct
     {
         mixin volatile_uint!"subreg";
     };
}

void vtest()
{
     S * s = cast(S *)0xDEADBEEF;
     while (s.reg == 0)
     {
         s.subreg = 1;
     }
}
```

This works and I like from the user side being able to access 
each field as if it was just the normal field. However, declaring 
the fields is a bit uglier syntax.

# Questions

Between the two of these attempts I'm leaning toward #2 because 
of the easier user syntax to read/write the fields.

I am wondering:

1. Is there any way to improve attempt #1 to not require the 
.get() call? I tried with opCast() but that requires the user to 
do an explicit cast which I felt was even worse than the .get
1. Is there any way to improve attempt #2 to make field 
declaration cleaner than `mixin volatile_uint!"reg"`?
1. Is there any other way of achieving what I'm trying to achieve 
different from these two methods?