The X Macro using D

[Enamex via Digitalmars-d]

On Thursday, 20 July 2017 at 22:02:32 UTC, Walter Bright wrote:
> On 7/20/2017 2:21 PM, Stefan Koch wrote:
>> Please tell me this is not going to get into dmd :)
>> templates are so much more expensive then macros.
>> (Well, for now :) )
>> 
>> Those templates can and should be replaced by CTFE.
>
> If you like, present the CTFE solution. Should be fun!

How about this (if I'm not mistaken, this's only one template 
instantiation per tuple-type&extracted-index):

```d

import std.typecons: tuple, Tuple;
import std.algorithm: map;
import std.array: array;

enum regm_t {
     AX, BX, CX, DX, DI, SI, None
}

enum tym_t {
     uchar_, ushort_, ulong_
}

enum Ydata = [
     tuple("AH",   4, regm_t.AX,   tym_t.uchar_),
     tuple("AL",   0, regm_t.AX,   tym_t.uchar_),
     tuple("AX",   8, regm_t.AX,   tym_t.ushort_),
     tuple("BH",   7, regm_t.BX,   tym_t.uchar_),
     tuple("BL",   3, regm_t.BX,   tym_t.uchar_),
     tuple("BP",  13, regm_t.None, tym_t.ushort_),
     tuple("BX",  11, regm_t.BX,   tym_t.ushort_),
     tuple("CH",   5, regm_t.CX,   tym_t.uchar_),
     tuple("CL",   1, regm_t.CX,   tym_t.uchar_),
     tuple("CX",   9, regm_t.CX,   tym_t.ushort_),
     tuple("DH",   6, regm_t.DX,   tym_t.uchar_),
     tuple("DI",  15, regm_t.DI,   tym_t.ushort_),
     tuple("DL",   2, regm_t.DX,   tym_t.uchar_),
     tuple("DX",  10, regm_t.DX,   tym_t.ushort_),
     tuple("EAX", 16, regm_t.AX,   tym_t.ulong_),
     tuple("EBP", 21, regm_t.None, tym_t.ulong_),
     tuple("EBX", 19, regm_t.BX,   tym_t.ulong_),
     tuple("ECX", 17, regm_t.CX,   tym_t.ulong_),
     tuple("EDI", 23, regm_t.DI,   tym_t.ulong_),
     tuple("EDX", 18, regm_t.DX,   tym_t.ulong_),
     tuple("ESI", 22, regm_t.SI,   tym_t.ulong_),
     tuple("ESP", 20, regm_t.None, tym_t.ulong_),
     tuple("SI",  14, regm_t.SI,   tym_t.ushort_),
     tuple("SP",  12, regm_t.None, tym_t.ushort_),
];

static auto Y(size_t idx, T...)(Tuple!(T)[] ts) pure nothrow {
     // I thought to try something like assumeUnique here
     // but was thinking of the Rust semantics in doing so
     // Not sure if this leads to spurious allocations at
     // the points where Y is used. Is there someway to tell them,
     // even if the target type is const or immutable
     // that this returned array is brand new with no other 
references
     // around?
     return ts
             .map!(x => x[idx])
             .array
             ;
}

enum {
     Xtab = 0,
     Xreg,
     Xmask,
     Xty,
}

// Register number to use in addressing mode
private __gshared const(char)*[24] pseudotab = Y!Xtab(Ydata);


// Register number to use in addressing mode
__gshared ubyte[24] pseudoreg = Y!Xreg(Ydata);


// Mask to use for registers affected
__gshared regm_t[24] pseudomask = Y!Xmask(Ydata);


// Table for type of pseudo register variable
private __gshared const(tym_t)[24] pseudoty = Y!Xty(Ydata);
```