Question

我想将解析后的ttf文件中的一些信息转储到XML文件中。 ttf中有几个表，例如cmap，head，hhea。我已经定义了这些表的结构，例如：

class Font_Header{
public:
    FIXED   table_version_number;
    FIXED   font_revision;
    ULONG   checksum_adjustment;
// some other field...
    SHORT   index_to_loc_format;
    SHORT   glygh_data_format;
// some member functions...
};

现在我想写一个名为dump_info的函数来转储这个结构的内存布局。

void Font_Header::dump_info(FILE *fp, size_t indent){
    INDENT(fp, indent); fprintf(fp, "<head>\n");
    ++indent;
    INDENT(fp, indent); fprintf(fp, "<tableVersion value=\"0x%08x\"/>\n", table_version_number);
// some other lines...
    INDENT(fp, indent); fprintf(fp, "<glyphDataFormat value=\"%d\"/>\n", glygh_data_format);
    --indent;
    INDENT(fp, indent); fprintf(fp, "</head>\n");
}

我的问题是：

有没有更好的解决方案来实现这一目标？我已经编写N行来定义结构，现在我必须将另外N行写入dump_info。这不酷。我想要的东西就像：
```
foreach field in fields
    dump(indent);
    dumpLn("<$1 value=\"$2\">", field.name, field.value);
    // Fields of different type are dumped in different format!
end
```

如何明智地完成缩进？我定义了以下宏

#define INDENT(fp, indent) for(size_t i = 0; i < (indent); ++i) fprintf((fp), "\t")

并将此宏附加到每一行......我想知道是否有一种优雅的方式来完成这项任务。

Answer 1

以下代码是我的尝试。我将类的字段信息存储到Notation数组中。我假设ULL，即unsigned long long，是消耗最大内存（8B）的类型，并且始终从每个字段的指针获得8B。有一点需要特别谨慎对待，我应该始终确保在format中正确分配了Notation。例如，如果我想要打印short值（我只需要2B），但是我将format分配给"%d"（对我来说是获取4B），我会得到错误的答案。< / p>

两个问题仍然困扰着我：

该方法不可移植。不同的平台可能会为ULL分配不同大小的内存。
由于我总是从内存中获取8B，放弃效率，这可能会导致读取内存违规。

好了，更新...我将mask添加到Notation以获取正确的值，即使format未正确分配也是如此。

请参阅ttf中的OS/2表。它由近40个领域组成。现在我写了40行来定义表，40行读取表，40行转储信息！天啊。也许将来我要添加其他40行，40行和40行...如果我不能自动完成这项任务，请杀了我。

#include <stdio.h>

class X{
public:
  char      a;
  short     b;
  int       c;
  double    d;
  X(char a, short b, int c, double d) : a(a), b(b), c(c), d(d) {}
};

typedef unsigned long long ULL;
#define FIELD(c, x)             (((c*)0)->x)
#define OFFSET(c, x)            ((size_t)&FIELD(c, x))
#define SIZE(c, x)              (sizeof(FIELD(c, x)))
#define MASK(c, x)              (((ULL)~0) >> ((sizeof(ULL) - SIZE(c, x)) << 3))
#define NOTATION(c, x, s)       { SIZE(c, x), OFFSET(c, x), #x, s, MASK(c, x) }
#define PTR(c, f)               ((void*)((size_t)&c + f->offset))
#define VALUE(c, f)             (f->mask & *(ULL*)PTR(x, f))
struct Notation{
  size_t        size;
  size_t        offset;
  const char    *name;
  const char    *format;
  ULL           mask;
};

Notation X_field[] = {
  NOTATION(X, a, "%c"),
  NOTATION(X, b, "%d"),  // The right 'format' of short should be %hd. I intentionally set it wrong.
  NOTATION(X, c, "%d"),
  NOTATION(X, d, "%lf")
};

#define PRINT(x, f, s) \
  printf("name: %s, size: %u, ptr: %p, value: " s "\n", #f, sizeof(x.f), &x.f, x.f)

int main(){
  X x('z', 3, 2, 1.5);
  printf("--------------------MANUAL--------------------\n");
  PRINT(x, a, "%c");
  PRINT(x, b, "%hd");
  PRINT(x, c, "%d");
  PRINT(x, d, "%lf");
  printf("--------------------MASK--------------------\n");
  printf("0x%016hhx, %hhu\n", (char)~0, (char)~0);
  printf("0x%016hx, %hu\n", (short)~0, (short)~0);
  printf("0x%016x, %u\n", (int)~0, (int)~0);
  printf("0x%016llx, %llu\n", (ULL)~0, (ULL)~0);
  printf("--------------------FIELD--------------------\n");
  Notation *field = NULL;
  int i = 0;
  for(i = 0, field = X_field; i < 4; ++i, ++field){
    printf("size: %u, offset: %u, name: %s, format: %s, mask: 0x%016llx\n",
      field->size, field->offset, field->name, field->format, field->mask);
  }

  printf("--------------------AUTO--------------------\n");
  for(i = 0, field = X_field; i < 4; ++i, ++field){
    printf("name: %s, size: %u, ptr: %p, value: ", field->name, field->size, PTR(x, field));
    printf(field->format, VALUE(x, field));
    printf("\n");
  }
  return 0;
}

输出：

--------------------MANUAL--------------------
name: a, size: 1, ptr: 0x22ac18, value: z
name: b, size: 2, ptr: 0x22ac1a, value: 3
name: c, size: 4, ptr: 0x22ac1c, value: 2
name: d, size: 8, ptr: 0x22ac20, value: 1.500000
--------------------MASK--------------------
0x00000000000000ff, 255
0x000000000000ffff, 65535
0x00000000ffffffff, 4294967295
0xffffffffffffffff, 18446744073709551615
--------------------FIELD--------------------
size: 1, offset: 0, name: a, format: %c, mask: 0x00000000000000ff
size: 2, offset: 2, name: b, format: %d, mask: 0x000000000000ffff
size: 4, offset: 4, name: c, format: %d, mask: 0x00000000ffffffff
size: 8, offset: 8, name: d, format: %lf, mask: 0xffffffffffffffff
--------------------AUTO--------------------
name: a, size: 1, ptr: 0x22ac18, value: z
name: b, size: 2, ptr: 0x22ac1a, value: 3
name: c, size: 4, ptr: 0x22ac1c, value: 2
name: d, size: 8, ptr: 0x22ac20, value: 1.500000

Answer 2

如果您只是做了一些案例，只需手动完成并与重复一起生活。

如果您只是为很多的简单结构执行此操作，我会考虑使用一个简单的解析器将给定头文件中的结构转换为转储结构的源。

如果我想能够更多地自定义XML输出（这似乎很可能），我会从某个元数据文件中生成结构和结构打印功能。

如果你不仅仅为简单的结构做这个，那么我将我的数据部分包装在一个简单的结构中，并按上述方式执行。

例如，你可以使用这样的东西:(我可能会使用XML或JSON元数据，因为它可以更容易解析 - 取决于你想用什么语言编写你的生成器）

<强> FontHeaderData.crazymeta

struct_name : Font_Header_data
dumper_name : Font_Header_data_to_xml
xml_root_node : head
FIXED table_version_number tableVersionNumber 0x%08x
...

然后您的主文件将如下所示：

<强> Font_Header.h

#include "Font_Header_data.h"
#include "Font_Header_data_to_xml.h"

class Font_Header {
    Font_Header_data data;
    void dump_info(FILE *fp, size_t indent){
        Font_Header_data_to_xml(fp,indent);
    }
};

您的解析器生成了Font_Header_data.h，Font_Header_data_to_xml.h和Font_Header_data_to_xml.c。

请记住使用正确的依赖项将您生成的文件链接到构建过程中，以便在正确的时间重建它们。

“有趣”部分是将元数据写入.c和.h转换器。

在过去，我做了类似的工作，以保持大量MySQL表与C ++对应物不同步，并生成正确的C API INSERT / UPDATE命令以在两者之间建立桥接。虽然从一开始就做了很多工作，但它确实为我节省了数小时的痛苦。

如何以优雅的方式转储XML？

2 个答案: