well, here you are:
http://www.dsource.org/projects/dexcelapi/browser/trunk/src/dxl/util/ctfe.d
and here is where I use it:
http://www.dsource.org/projects/dexcelapi/browser/trunk/src/dxl/biff/Enums.d
I don't think it's worth the effort of changing that stuff to work with
your table parsing, but if you make your tables work with '\u2500' and
friends, I might do it..
On 04/22/2010 12:36 PM, FeepingCreature wrote:
On 21.04.2010 16:43, Ellery Newcomer wrote:
On 04/21/2010 05:43 AM, FeepingCreature wrote:
On 20.04.2010 01:49, Ellery Newcomer wrote:
Are there any good libraries for ctfe/code generation?
I don't know, things like parsing support for compile time strings,
string formatting, type<-> string
My project seems to be growing ctfe, and it's all horribly hacky and
ugly code.
This might be useful if you're on D1:
http://dsource.org/projects/scrapple/browser/trunk/tools/tools/ctfe.d
Looks like itś exactly what I want, thanks!
A couple notes:
Is there any particular license associated with it? (whatever tangoś is
would be fine)
Feel free to use it as you wish.
When I try to compile, I get forward referencing errors and had to take
out the import to tools.compat
Yeah, nevermind that, it just defines string as char[] .. or used to, I think
that's in tools.text nowadays. tools.ctfe is pretty independent from the rest
of tools.
Also, are there any examples for usage of the table parsing functions?
Here's one from my IF language, for converting dynamic into native types:
union {
bool b;
int i;
string s;
float f;
Scope sr;
}
T to(T)() {
const string Table = `
| bool | int | string | float
| Scope
-----------+---------------+-------------+----------------------+---------+----------
Boolean | b | b | b?q{true}p:q{false}p | ø
| ø
Integer | i != 0 | i | Format(i) | i
| ø
String | s == q{true}p | atoi(s) | s |
atof(s) | ø
Float | ø | cast(int) f | Format(f) | f
| ø
ScopeRef | !!sr | ø | (sr?sr.fqn:q{(null:r)}p) | ø
| sr
ScopeValue | sr.value().to!(T) | sr.value().to!(T) | sr.value().to!(T) |
sr.value().to!(T) | sr`;
mixin(ctTableUnrollColMajor(Table,
/* First parameter is the outer template, $COL substituting with the
column name, and $BODY substituting with the inner template*/
`static if (is(T == $COL))
switch (flatType) {
$BODY
default: throw new Exception(Format("Invalid type: ", flatType));
}
else `,
/* Second parameter is the inner template, $ROW substituting with the
row name and $CELL with the cell's content.
`case FlatType.$ROW:
static if (q{$CELL}p == "ø")
throw new Exception(q{Cannot convert $ROW to $COL:
}p~to!(string)~q{! }p);
else return $CELL;
`
).litstring_expand() /* expand q{}p into ""s with correct nesting */ ~ `static
assert(false, "Unsupported type: "~T.stringof); `);
}
And to whom do I give attribution?
Attribution is not necessary. I'm glad someone finds it useful.
