检测执行字符集字母是否连续
Detect if execution character set letters are contiguous
在代码中，一个开关用于将字母转换为连续值。优化编译器通常不会像切换前的简单连续数字条件那样完成这项工作。我如何检测使用了哪个执行字符集 and/or 断定字母是连续的以用简单的条件替换它？
static long digit_value(char c)
{
if (c >= '0' && c <= '9')
return (c-'0');
switch(c) {
case 'a':
case 'A':
return 10;
case 'b':
case 'B':
return 11;
case 'c':
case 'C':
return 12;
case 'd':
case 'D':
return 13;
case 'e':
case 'E':
return 14;
case 'f':
case 'F':
return 15;
case 'g':
case 'G':
return 16;
case 'h':
case 'H':
return 17;
case 'i':
case 'I':
return 18;
case 'j':
case 'J':
return 19;
case 'k':
case 'K':
return 20;
case 'l':
case 'L':
return 21;
case 'm':
case 'M':
return 22;
case 'n':
case 'N':
return 23;
case 'o':
case 'O':
return 24;
case 'p':
case 'P':
return 25;
case 'q':
case 'Q':
return 26;
case 'r':
case 'R':
return 27;
case 's':
case 'S':
return 28;
case 't':
case 'T':
return 29;
case 'u':
case 'U':
return 30;
case 'v':
case 'V':
return 31;
case 'w':
case 'W':
return 32;
case 'x':
case 'X':
return 33;
case 'y':
case 'Y':
return 34;
case 'z':
case 'Z':
return 35;
default:
break;
}
return -1;
}
How can I detect which execution character set used and/or conclude that the letters are contiguous?
在编译时，简单地测试它们。 （'a-z' 为简单起见省略）
static_assert(
'A' == ('B' - 1) &&
'B' == ('C' - 1) && 'C' == ('D' - 1) && 'D' == ('E' - 1) && 'E' == ('F' - 1) && 'F' == ('G' - 1) && 'G' == ('H' - 1) && 'H' == ('I' - 1) && 'I' == ('J' - 1) && 'J' == ('K' - 1) && 'K' == ('L' - 1) && 'L' == ('M' - 1) && 'M' == ('N' - 1) && 'N' == ('O' - 1) && 'O' == ('P' - 1) && 'P' == ('Q' - 1) && 'Q' == ('R' - 1) && 'R' == ('S' - 1) && 'S' == ('T' - 1) && 'T' == ('U' - 1) && 'U' == ('V' - 1) && 'V' == ('W' - 1) && 'W' == ('X' - 1) && 'X' == ('Y' - 1) &&
'Y' == ('Z' - 1), "Dinosaur: not continuous A-Z");
static int digit_value(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
return -1;
}
或者使用速度慢但高度portable:
static int digit_value(char c) {
static const char *base36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char *p = strchr(base36, (unsigned char) c);
if (p && *p) {
return (int) (p - base36);
}
return -1;
}
或者可能是一个大 #if？
#if ('A' == ('B' - 1) && 'B' == ('C' - 1) && 'C' == ('D' - 1) && 'D' == ('E' - 1) && 'E' == ('F' - 1) && 'F' == ('G' - 1) && 'G' == ('H' - 1) && 'H' == ('I' - 1) && 'I' == ('J' - 1) && 'J' == ('K' - 1) && 'K' == ('L' - 1) && 'L' == ('M' - 1) && 'M' == ('N' - 1) && 'N' == ('O' - 1) && 'O' == ('P' - 1) && 'P' == ('Q' - 1) && 'Q' == ('R' - 1) && 'R' == ('S' - 1) && 'S' == ('T' - 1) && 'T' == ('U' - 1) && 'U' == ('V' - 1) && 'V' == ('W' - 1) && 'W' == ('X' - 1) && 'X' == ('Y' - 1) && 'Y' == ('Z' - 1))
static int digit_value(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
return -1;
}
#else
static int digit_value(char c) {
static const char *base36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char *p = strchr(base36, (unsigned char) c);
if (p && *p) {
return (int) (p - base36);
}
return -1;
}
#endif
或者 ....如果 UCHAR_MAX 不太大并且不关心速度，请查找 table 并跳过顺序问题。
#include <limits.h>
int digit_value(char c) {
unsigned char val[UCHAR_MAX] = {['0'] = 1, ['1'] = 2, ['2'] = 3, ['3'] = 4,
['4'] = 5, ['5'] = 6, ['6'] = 7, ['7'] = 8, ['9'] = 10,
['A'] = 11, ['B'] = 12, ['C'] = 13, ['D'] = 14, ['E'] = 15, ...
['a'] = 11, ['b'] = 12, ['c'] = 13, ['d'] = 14, ['e'] = 15, ...
};
return val[(unsigned char) c] - 1;
}
首先我不得不说我会选择预处理器解决方案，因为编译器的字符集是我想在编译时 发现的信息。
_static_assert 将是一个优雅的解决方案，但由于 它仅在 C11 标准中引入，真实 恐龙不太可能支持它。
我将使用带有 #if 链的通用预处理器指令执行检查，每个指令确保一个字符的表示与前一个字符的表示是连续的。
一个简单的运行时检查
编译时间检查已经被其他答案很好地涵盖了，所以我只想建议一个简单的运行时排除方法EBCDIC 字符集：假设是 字符集可以是 EBCDIC 或 ASCII 的场景。
这样，通过排除 EBCDIC，我们可以假设使用的是 ASCII 字符集，因此字符是连续的。
只需考虑两个简单的 EBCDIC 特征：
- 具有非连续十进制表示的字母是众所周知的（例如
'j' != 'i'+1）
- 字母字符 应该 在所有数百个 EBCDIC 变体中具有共同的十进制表示，如 IBM 页面中所推荐：invariant charset
所以：
static long digit_value(char c)
{
if (c >= '0' && c <= '9')
return (c-'0');
if ( 'j' == 'i'+1 ) //if it's not EBCDIC
{
if( c >= 'a' && c <= 'z' )
{
return 10 + c - 'a';
}
else if ( c >= 'A' && c <= 'Z' )
{
return 10 + c - 'A';
}
}
return -1;
}
如果是 EBCDIC 字符集，则返回错误代码，如果是 ASCII 字符集，则一个简单的条件确保为小写和大写字符返回 [10 - 35] 范围。
正如@chux 回答的那样，您可以为条件编译编写适当的测试。但是，如果您需要支持具有非连续字母的字符集，那么您需要一个支持它的实现，并且 table 查找会比您在问题中提出的更有效。如此之多，以至于您可以考虑在所有情况下都使用它，而不是维护两个单独的实现。例如：
static long digit_value(char c) {
static const long dvs[UCHAR_MAX + 1] = {
[0] = 1, [1] = 2, [2] = 3, [3] = 4, [5] = 6, [7] = 8, [8] = 9, [9] = 10,
['A'] = 11, ['B'] = 12, ['C'] = 13, ['D'] = 14, ['E'] = 15, ['F'] = 16, ['G'] = 17,
['H'] = 18, ['I'] = 19, ['J'] = 20, ['K'] = 21, ['L'] = 22, ['M'] = 23, ['N'] = 24,
['O'] = 25, ['P'] = 26, ['Q'] = 27, ['R'] = 28, ['S'] = 29, ['T'] = 30, ['U'] = 31,
['V'] = 32, ['W'] = 33, ['X'] = 34, ['Y'] = 35, ['Z'] = 36,
['a'] = 11, ['b'] = 12, ['c'] = 13, ['d'] = 14, ['e'] = 15, ['f'] = 16, ['g'] = 17,
['h'] = 18, ['i'] = 19, ['j'] = 20, ['k'] = 21, ['l'] = 22, ['m'] = 23, ['n'] = 24,
['o'] = 25, ['p'] = 26, ['q'] = 27, ['r'] = 28, ['s'] = 29, ['t'] = 30, ['u'] = 31,
['v'] = 32, ['w'] = 33, ['x'] = 34, ['y'] = 35, ['z'] = 36
};
return dvs[(unsigned char) c] - 1;
}
请注意，基本执行字符集中的字符，包括所有十进制数字和大小写拉丁字母，保证具有非负整数值。这在某种程度上简化了 table 的初始化程序。另请注意，未显式初始化的元素将默认初始化为零，最终通过从列表值中减去 1 将其转换为 -1 return 值。
成为table并且最有效地使用查找table
const char table[128] = {
['0'] = 0, ['1'] = 1, /* ... */ ['9'] = 9,
['a'] = 10, ['A'] = 10,
['b'] = 11, ['B'] = 11,
['c'] = 12, ['C'] = 12,
['d'] = 13, ['D'] = 13,
['e'] = 14, ['E'] = 14,
['f'] = 15, ['f'] = 15,
['g'] = 16, ['g'] = 16,
['h'] = 17, ['H'] = 17,
['i'] = 18, ['I'] = 18,
['j'] = 19, ['J'] = 19,
/* etc etc */
};
int get_value(char ch)
{
return table[ch & 0x7f];
}
和生成的代码：
get_value:
movsx rdi, dil
movsx eax, BYTE PTR table[rdi]
ret
在代码中，一个开关用于将字母转换为连续值。优化编译器通常不会像切换前的简单连续数字条件那样完成这项工作。我如何检测使用了哪个执行字符集 and/or 断定字母是连续的以用简单的条件替换它？
static long digit_value(char c)
{
if (c >= '0' && c <= '9')
return (c-'0');
switch(c) {
case 'a':
case 'A':
return 10;
case 'b':
case 'B':
return 11;
case 'c':
case 'C':
return 12;
case 'd':
case 'D':
return 13;
case 'e':
case 'E':
return 14;
case 'f':
case 'F':
return 15;
case 'g':
case 'G':
return 16;
case 'h':
case 'H':
return 17;
case 'i':
case 'I':
return 18;
case 'j':
case 'J':
return 19;
case 'k':
case 'K':
return 20;
case 'l':
case 'L':
return 21;
case 'm':
case 'M':
return 22;
case 'n':
case 'N':
return 23;
case 'o':
case 'O':
return 24;
case 'p':
case 'P':
return 25;
case 'q':
case 'Q':
return 26;
case 'r':
case 'R':
return 27;
case 's':
case 'S':
return 28;
case 't':
case 'T':
return 29;
case 'u':
case 'U':
return 30;
case 'v':
case 'V':
return 31;
case 'w':
case 'W':
return 32;
case 'x':
case 'X':
return 33;
case 'y':
case 'Y':
return 34;
case 'z':
case 'Z':
return 35;
default:
break;
}
return -1;
}
How can I detect which execution character set used and/or conclude that the letters are contiguous?
在编译时，简单地测试它们。 （'a-z' 为简单起见省略）
static_assert(
'A' == ('B' - 1) &&
'B' == ('C' - 1) && 'C' == ('D' - 1) && 'D' == ('E' - 1) && 'E' == ('F' - 1) && 'F' == ('G' - 1) && 'G' == ('H' - 1) && 'H' == ('I' - 1) && 'I' == ('J' - 1) && 'J' == ('K' - 1) && 'K' == ('L' - 1) && 'L' == ('M' - 1) && 'M' == ('N' - 1) && 'N' == ('O' - 1) && 'O' == ('P' - 1) && 'P' == ('Q' - 1) && 'Q' == ('R' - 1) && 'R' == ('S' - 1) && 'S' == ('T' - 1) && 'T' == ('U' - 1) && 'U' == ('V' - 1) && 'V' == ('W' - 1) && 'W' == ('X' - 1) && 'X' == ('Y' - 1) &&
'Y' == ('Z' - 1), "Dinosaur: not continuous A-Z");
static int digit_value(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
return -1;
}
或者使用速度慢但高度portable:
static int digit_value(char c) {
static const char *base36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char *p = strchr(base36, (unsigned char) c);
if (p && *p) {
return (int) (p - base36);
}
return -1;
}
或者可能是一个大 #if？
#if ('A' == ('B' - 1) && 'B' == ('C' - 1) && 'C' == ('D' - 1) && 'D' == ('E' - 1) && 'E' == ('F' - 1) && 'F' == ('G' - 1) && 'G' == ('H' - 1) && 'H' == ('I' - 1) && 'I' == ('J' - 1) && 'J' == ('K' - 1) && 'K' == ('L' - 1) && 'L' == ('M' - 1) && 'M' == ('N' - 1) && 'N' == ('O' - 1) && 'O' == ('P' - 1) && 'P' == ('Q' - 1) && 'Q' == ('R' - 1) && 'R' == ('S' - 1) && 'S' == ('T' - 1) && 'T' == ('U' - 1) && 'U' == ('V' - 1) && 'V' == ('W' - 1) && 'W' == ('X' - 1) && 'X' == ('Y' - 1) && 'Y' == ('Z' - 1))
static int digit_value(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
return -1;
}
#else
static int digit_value(char c) {
static const char *base36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const char *p = strchr(base36, (unsigned char) c);
if (p && *p) {
return (int) (p - base36);
}
return -1;
}
#endif
或者 ....如果 UCHAR_MAX 不太大并且不关心速度，请查找 table 并跳过顺序问题。
#include <limits.h>
int digit_value(char c) {
unsigned char val[UCHAR_MAX] = {['0'] = 1, ['1'] = 2, ['2'] = 3, ['3'] = 4,
['4'] = 5, ['5'] = 6, ['6'] = 7, ['7'] = 8, ['9'] = 10,
['A'] = 11, ['B'] = 12, ['C'] = 13, ['D'] = 14, ['E'] = 15, ...
['a'] = 11, ['b'] = 12, ['c'] = 13, ['d'] = 14, ['e'] = 15, ...
};
return val[(unsigned char) c] - 1;
}
首先我不得不说我会选择预处理器解决方案，因为编译器的字符集是我想在编译时 发现的信息。
_static_assert 将是一个优雅的解决方案，但由于 它仅在 C11 标准中引入，真实 恐龙不太可能支持它。
我将使用带有 #if 链的通用预处理器指令执行检查，每个指令确保一个字符的表示与前一个字符的表示是连续的。
一个简单的运行时检查
编译时间检查已经被其他答案很好地涵盖了，所以我只想建议一个简单的运行时排除方法EBCDIC 字符集：假设是 字符集可以是 EBCDIC 或 ASCII 的场景。
这样，通过排除 EBCDIC，我们可以假设使用的是 ASCII 字符集，因此字符是连续的。
只需考虑两个简单的 EBCDIC 特征：
- 具有非连续十进制表示的字母是众所周知的（例如
'j' != 'i'+1） - 字母字符 应该 在所有数百个 EBCDIC 变体中具有共同的十进制表示，如 IBM 页面中所推荐：invariant charset
所以：
static long digit_value(char c)
{
if (c >= '0' && c <= '9')
return (c-'0');
if ( 'j' == 'i'+1 ) //if it's not EBCDIC
{
if( c >= 'a' && c <= 'z' )
{
return 10 + c - 'a';
}
else if ( c >= 'A' && c <= 'Z' )
{
return 10 + c - 'A';
}
}
return -1;
}
如果是 EBCDIC 字符集，则返回错误代码，如果是 ASCII 字符集，则一个简单的条件确保为小写和大写字符返回 [10 - 35] 范围。
正如@chux 回答的那样，您可以为条件编译编写适当的测试。但是，如果您需要支持具有非连续字母的字符集，那么您需要一个支持它的实现，并且 table 查找会比您在问题中提出的更有效。如此之多，以至于您可以考虑在所有情况下都使用它，而不是维护两个单独的实现。例如：
static long digit_value(char c) {
static const long dvs[UCHAR_MAX + 1] = {
[0] = 1, [1] = 2, [2] = 3, [3] = 4, [5] = 6, [7] = 8, [8] = 9, [9] = 10,
['A'] = 11, ['B'] = 12, ['C'] = 13, ['D'] = 14, ['E'] = 15, ['F'] = 16, ['G'] = 17,
['H'] = 18, ['I'] = 19, ['J'] = 20, ['K'] = 21, ['L'] = 22, ['M'] = 23, ['N'] = 24,
['O'] = 25, ['P'] = 26, ['Q'] = 27, ['R'] = 28, ['S'] = 29, ['T'] = 30, ['U'] = 31,
['V'] = 32, ['W'] = 33, ['X'] = 34, ['Y'] = 35, ['Z'] = 36,
['a'] = 11, ['b'] = 12, ['c'] = 13, ['d'] = 14, ['e'] = 15, ['f'] = 16, ['g'] = 17,
['h'] = 18, ['i'] = 19, ['j'] = 20, ['k'] = 21, ['l'] = 22, ['m'] = 23, ['n'] = 24,
['o'] = 25, ['p'] = 26, ['q'] = 27, ['r'] = 28, ['s'] = 29, ['t'] = 30, ['u'] = 31,
['v'] = 32, ['w'] = 33, ['x'] = 34, ['y'] = 35, ['z'] = 36
};
return dvs[(unsigned char) c] - 1;
}
请注意，基本执行字符集中的字符，包括所有十进制数字和大小写拉丁字母，保证具有非负整数值。这在某种程度上简化了 table 的初始化程序。另请注意，未显式初始化的元素将默认初始化为零，最终通过从列表值中减去 1 将其转换为 -1 return 值。
成为table并且最有效地使用查找table
const char table[128] = {
['0'] = 0, ['1'] = 1, /* ... */ ['9'] = 9,
['a'] = 10, ['A'] = 10,
['b'] = 11, ['B'] = 11,
['c'] = 12, ['C'] = 12,
['d'] = 13, ['D'] = 13,
['e'] = 14, ['E'] = 14,
['f'] = 15, ['f'] = 15,
['g'] = 16, ['g'] = 16,
['h'] = 17, ['H'] = 17,
['i'] = 18, ['I'] = 18,
['j'] = 19, ['J'] = 19,
/* etc etc */
};
int get_value(char ch)
{
return table[ch & 0x7f];
}
和生成的代码：
get_value:
movsx rdi, dil
movsx eax, BYTE PTR table[rdi]
ret