d二进制字面

我也反对丢弃二进制字面.虽然我不经常使用它们,但有几次我确实需要它们,我很高兴它们在那里.它是C缺少的D优点之一,如果放弃它会相当失望.不得不求助于模板来使用二进制字面会很痛苦.
八进制的丢弃也没有那么成功.应该选择0o
编译器仍在正确解析八进制字面.
0o对八进制完全有意义,就像0x对十六进制完全有意义一样
编译器中有类型推导逻辑:

import std.conv: o=octal;

void main(){
    auto x0=o!1000000000;
    static assert(is(typeof(x0)==int));
    auto x1=o!10000000000;
    static assert(is(typeof(x1)==long));
}
1
2
3
4
5
6
7
8

C++11起就有用户定义的字面.一般以"_字面"结尾,如300_km.支持串和值字面.
好处是D可以让你用下划线对位分组.
因此,可能会喜欢0b11_111_101_001这使它更易管理,并且可像在文档中,分组标志寄存器.
作为语言功能的东西都应该是保持该功能开箱即用的对象.
这有明显的视觉含义,但在十六进制中很难阅读.

0b111111
0b100001
0b100001
0b111111
1
2
3
4

对象是隐式导入的,因此可在全局命名空间中获取内容.模块系统有办法消歧,但我一般还是更喜欢显式导入来保持清晰,特别是如果没有导入来清理它,错误消息可能会相当糟糕.
throw new Exception("串")不好,但最方便.
删除几十年来拥有的二进制字面会*伤害*D.
摆脱奇怪的极端情况和任意限制.
ImportC对D来说是一个巨大的胜利.我应该一开始就这样做.
是否会再次忽略社区几乎一致的反馈并删除二进制字面?

在为C实现它之后,我发现可简单地打开现有实现来添加位域到D.代码已经存在,已支持并调试.
更喜欢模板方法,它没有C方法所具有的简单语法,而位域可证明更简单的内置语法是合理的.
在为D打开它时,它暴露了1个严重错误,我为C端编写的大量测试错过了该错误.

把它包装在串字面中,并编写简单解析器来翻译它为二进制数据.
这样很容易向反汇编程序添加测试用例.非常值得为此付出额外的努力来制作小型解析器.
编写简单解析器,并用CTFE生成表中二进制数据.当然,这样,解析器可反复用于其他项目.

enum Flag  = {
  CARRY    =    1,
  SIGN     =    2,
  OVERFLOW =    4,
  PARITY   =    8,
  ZERO     = 0x10,
  ... 
}
1
2
3
4
5
6
7
8

我一直使用上面二进制标志.要了解:

比等效的十六进制更容易理解
我更喜欢内置的位域系统.

{
assert(beststraight(0b10000000011110) == Rank.Five);
assert(beststraight(0b10101111111110) == Rank.Ten);
}
1
2
3
4

以八进制表示的8080/8085/Z80操作码更容易处理.仿真器是个小众领域,但许多CPU和外围寄存器通常具有八进制字段.当然,十六进制通常足以处理它们.
我从未见过以八进制表示的8080/Z80操作码.我知道x86的modregrm字节是2,3,3,但我通过使用内联函数来处理它.我从来没有想过使用八进制.有趣的.

ubyte modregrm (uint m, uint r, uint rm){
     return cast(ubyte)((m << 6) | (r << 3) | rm); 
}
1
2
3

当然,位域可能会更好,:-)
我开始实施ImportC时,我重新发现了所有我不喜欢的东西,但它们已经在D中修复了.

writeln(format("%b", 0xcc));
1

解析工具:

ulong parse(const char[] data){
    ulong result = 0;
    foreach(ch; data){
        switch(ch){
            case '.':
                result <<= 1;
                break;
            case 'x': case 'X':
                result <<= 1;
                result |= 1;
                break;
            case ' ': case '\t': case '\n': case '\r':
            case '_':
                continue;
            default:
                throw new Exception("oops");
        }
    }
    return result;
}

static assert("...".parse == 0b000);
static assert("..x".parse == 0b001);
static assert(".x.".parse == 0b010);
static assert(".xx".parse == 0b011);
static assert("x..".parse == 0b100);
static assert("x.x".parse == 0b101);
static assert("xx.".parse == 0b110);
static assert("xxx".parse == 0b111);
static assert("
        xxx
        x.x
        xxx
        ".parse == 0b111_101_111);
static assert("x.x.__x__.x.x".parse == 0b1010__1__0101);
private bool does_throw(const char[] data){
    bool caught = false;
    try { const _ = data.parse; }
    catch (Exception e){ caught = true; }
    return caught;
}
static assert(does_throw("x0x"));
static assert(does_throw("1010"));
static assert(does_throw("1010"));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44