HGRIDITEM FindGridItem(HGRIDITEM hParent, ExprNode * expr, HWND hwndGridView)
{
Symbol *sym;
HGRIDITEM hItem = 0;
Structure *parent;
GVITEM gvitem = { 0, 0, 0, GVIF_PARAM };
Type *t = TypeView_GetType(hwndGridView, hParent);
if(IsStruct(t) == false)
return 0;
parent = BaseNode(t)->sptr;
for(; expr; expr = expr->right)
{
// expr->left will always be EXPR_IDENTIFIER
if((sym = LookupSymbol(parent->symbolTable, expr->left ? expr->left->str : expr->str)) == 0)
return 0;
// look for the Type* node in the GridView
gvitem.iSubItem = COLIDX_NAME;
gvitem.mask = GVIF_PARAM;
gvitem.param = (ULONG_PTR)sym->type;
// this *should* succeed, but just in case...
if((hItem = GridView2_FindChild(hwndGridView, hParent, &gvitem)) == 0)
return 0;
Type *base = BaseNode(sym->type);
if(IsStruct(base) && expr->left)
{
//sptr = base->sptr;
parent = base->sptr;
hParent = hItem;
}
else if(expr->left == 0)
{
return hItem;
}
else
{
// lvalue is not a structure
return 0;
}
}
return 0;
}
// Return a C++ type for any type (scalar/pointer) that reflects its
// serialized size.
static std::string GenTypeSize(const Parser &parser, const Type &type) {
return IsScalar(type.base_type)
? GenTypeBasic(parser, type, false)
: IsStruct(type)
? GenTypePointer(parser, type)
: "flatbuffers::uoffset_t";
}
// Generate text for non-scalar field.
static void GenFieldOffset(const FieldDef &fd, const Table *table, bool fixed,
int indent, int indent_step, StructDef *union_sd,
std::string *_text) {
const void *val = nullptr;
if (fixed) {
// The only non-scalar fields in structs are structs.
assert(IsStruct(fd.value.type));
val = reinterpret_cast<const Struct *>(table)->
GetStruct<const void *>(fd.value.offset);
} else {
val = IsStruct(fd.value.type)
? table->GetStruct<const void *>(fd.value.offset)
: table->GetPointer<const void *>(fd.value.offset);
}
Print(val, fd.value.type, indent, indent_step, union_sd, _text);
}
// Return a C++ type for any type (scalar/pointer) specifically for
// building a flatbuffer.
static std::string GenTypeWire(const Type &type, const char *postfix) {
return IsScalar(type.base_type)
? GenTypeBasic(type) + postfix
: IsStruct(type)
? "const " + GenTypePointer(type) + " *"
: "flatbuffers::Offset<" + GenTypePointer(type) + ">" + postfix;
}
// Return a C++ type for any type (scalar/pointer) specifically for
// building a flatbuffer.
static std::string GenTypeWire(const Parser &parser, const Type &type,
const char *postfix, bool real_enum) {
return IsScalar(type.base_type)
? GenTypeBasic(parser, type, real_enum) + postfix
: IsStruct(type)
? "const " + GenTypePointer(parser, type) + " *"
: "flatbuffers::Offset<" + GenTypePointer(parser, type) + ">" + postfix;
}
// Recursively generate arguments for a constructor, to deal with nested
// structs.
static void GenStructArgs(const StructDef &struct_def, std::string *code_ptr,
const char *nameprefix) {
std::string &code = *code_ptr;
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (IsStruct(field.value.type)) {
// Generate arguments for a struct inside a struct. To ensure names
// don't clash, and to make it obvious these arguments are constructing
// a nested struct, prefix the name with the struct name.
GenStructArgs(*field.value.type.struct_def, code_ptr,
(field.value.type.struct_def->name + "_").c_str());
} else {
code += ", " + GenTypeBasic(field.value.type) + " " + nameprefix;
code += MakeCamel(field.name, false);
}
}
}
// Recusively generate struct construction statements of the form:
// builder.putType(name);
// and insert manual padding.
static void GenStructBody(const StructDef &struct_def, std::string *code_ptr,
const char *nameprefix) {
std::string &code = *code_ptr;
code += " builder.prep(" + NumToString(struct_def.minalign) + ", 0);\n";
for (auto it = struct_def.fields.vec.rbegin();
it != struct_def.fields.vec.rend();
++it) {
auto &field = **it;
if (field.padding)
code += " builder.pad(" + NumToString(field.padding) + ");\n";
if (IsStruct(field.value.type)) {
GenStructBody(*field.value.type.struct_def, code_ptr,
(field.value.type.struct_def->name + "_").c_str());
} else {
code += " builder.put" + GenMethod(field) + "(";
code += nameprefix + MakeCamel(field.name, false) + ");\n";
}
}
}
// Recursively generate arguments for a constructor, to deal with nested
// structs.
static void StructBuilderArgs(const StructDef &struct_def,
const char *nameprefix,
std::string *code_ptr) {
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (IsStruct(field.value.type)) {
// Generate arguments for a struct inside a struct. To ensure names
// don't clash, and to make it obvious these arguments are constructing
// a nested struct, prefix the name with the field name.
StructBuilderArgs(*field.value.type.struct_def,
(nameprefix + (field.name + "_")).c_str(),
code_ptr);
} else {
std::string &code = *code_ptr;
code += (std::string)", " + nameprefix;
code += MakeCamel(field.name, false);
}
}
}
// Recursively generate struct construction statements and instert manual
// padding.
static void StructBuilderBody(const StructDef &struct_def,
const char *nameprefix,
std::string *code_ptr) {
std::string &code = *code_ptr;
code += "\tbuilder.Prep(" + NumToString(struct_def.minalign) + ", ";
code += NumToString(struct_def.bytesize) + ")\n";
for (auto it = struct_def.fields.vec.rbegin();
it != struct_def.fields.vec.rend();
++it) {
auto &field = **it;
if (field.padding)
code += "\tbuilder.Pad(" + NumToString(field.padding) + ")\n";
if (IsStruct(field.value.type)) {
StructBuilderBody(*field.value.type.struct_def,
(nameprefix + (field.name + "_")).c_str(),
code_ptr);
} else {
code += "\tbuilder.Prepend" + GenMethod(field) + "(";
code += nameprefix + MakeCamel(field.name, false) + ")\n";
}
}
}
// Print a vector a sequence of JSON values, comma separated, wrapped in "[]".
template<typename T> void PrintVector(const Vector<T> &v, Type type,
int indent, int indent_step,
std::string *_text) {
std::string &text = *_text;
text += "[";
text += NewLine(indent_step);
for (uoffset_t i = 0; i < v.Length(); i++) {
if (i) {
text += ",";
text += NewLine(indent_step);
}
text.append(indent + indent_step, ' ');
if (IsStruct(type))
Print(v.GetStructFromOffset(i * type.struct_def->bytesize), type,
indent + indent_step, indent_step, nullptr, _text);
else
Print(v.Get(i), type, indent + indent_step, indent_step, nullptr, _text);
}
text += NewLine(indent_step);
text.append(indent, ' ');
text += "]";
}
// Print a vector a sequence of JSON values, comma separated, wrapped in "[]".
template<typename T> void PrintVector(const Vector<T> &v, Type type,
int indent, const IDLOptions &opts,
std::string *_text) {
std::string &text = *_text;
text += "[";
text += NewLine(opts);
for (uoffset_t i = 0; i < v.size(); i++) {
if (i) {
text += ",";
text += NewLine(opts);
}
text.append(indent + Indent(opts), ' ');
if (IsStruct(type))
Print(v.GetStructFromOffset(i * type.struct_def->bytesize), type,
indent + Indent(opts), nullptr, opts, _text);
else
Print(v[i], type, indent + Indent(opts), nullptr,
opts, _text);
}
text += NewLine(opts);
text.append(indent, ' ');
text += "]";
}
// Generate an accessor struct, builder structs & function for a table.
static void GenTable(const Parser &parser, StructDef &struct_def,
const GeneratorOptions &opts, std::string *code_ptr) {
if (struct_def.generated) return;
std::string &code = *code_ptr;
// Generate an accessor struct, with methods of the form:
// type name() const { return GetField<type>(offset, defaultval); }
GenComment(struct_def.doc_comment, code_ptr);
code += "struct " + struct_def.name;
code += " FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table";
code += " {\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) { // Deprecated fields won't be accessible.
GenComment(field.doc_comment, code_ptr, " ");
code += " " + GenTypeGet(parser, field.value.type, " ", "const ", " *",
true);
code += field.name + "() const { return ";
// Call a different accessor for pointers, that indirects.
std::string call = IsScalar(field.value.type.base_type)
? "GetField<"
: (IsStruct(field.value.type) ? "GetStruct<" : "GetPointer<");
call += GenTypeGet(parser, field.value.type, "", "const ", " *", false);
call += ">(" + NumToString(field.value.offset);
// Default value as second arg for non-pointer types.
if (IsScalar(field.value.type.base_type))
call += ", " + field.value.constant;
call += ")";
code += GenUnderlyingCast(parser, field, true, call);
code += "; }\n";
auto nested = field.attributes.Lookup("nested_flatbuffer");
if (nested) {
auto nested_root = parser.structs_.Lookup(nested->constant);
assert(nested_root); // Guaranteed to exist by parser.
code += " const " + nested_root->name + " *" + field.name;
code += "_nested_root() const { return flatbuffers::GetRoot<";
code += nested_root->name + ">(" + field.name + "()->Data()); }\n";
}
// Generate a comparison function for this field if it is a key.
if (field.key) {
code += " bool KeyCompareLessThan(const " + struct_def.name;
code += " *o) const { return ";
if (field.value.type.base_type == BASE_TYPE_STRING) code += "*";
code += field.name + "() < ";
if (field.value.type.base_type == BASE_TYPE_STRING) code += "*";
code += "o->" + field.name + "(); }\n";
code += " int KeyCompareWithValue(";
if (field.value.type.base_type == BASE_TYPE_STRING) {
code += "const char *val) const { return strcmp(" + field.name;
code += "()->c_str(), val); }\n";
} else {
code += GenTypeBasic(parser, field.value.type, false);
code += " val) const { return " + field.name + "() < val ? -1 : ";
code += field.name + "() > val; }\n";
}
}
}
}
// Generate a verifier function that can check a buffer from an untrusted
// source will never cause reads outside the buffer.
code += " bool Verify(flatbuffers::Verifier &verifier) const {\n";
code += " return VerifyTableStart(verifier)";
std::string prefix = " &&\n ";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) {
code += prefix + "VerifyField";
if (field.required) code += "Required";
code += "<" + GenTypeSize(parser, field.value.type);
code += ">(verifier, " + NumToString(field.value.offset);
code += " /* " + field.name + " */)";
switch (field.value.type.base_type) {
case BASE_TYPE_UNION:
code += prefix + "Verify" + field.value.type.enum_def->name;
code += "(verifier, " + field.name + "(), " + field.name + "_type())";
break;
case BASE_TYPE_STRUCT:
if (!field.value.type.struct_def->fixed) {
code += prefix + "verifier.VerifyTable(" + field.name;
code += "())";
}
break;
case BASE_TYPE_STRING:
code += prefix + "verifier.Verify(" + field.name + "())";
break;
case BASE_TYPE_VECTOR:
code += prefix + "verifier.Verify(" + field.name + "())";
switch (field.value.type.element) {
case BASE_TYPE_STRING: {
code += prefix + "verifier.VerifyVectorOfStrings(" + field.name;
code += "())";
break;
}
case BASE_TYPE_STRUCT: {
if (!field.value.type.struct_def->fixed) {
code += prefix + "verifier.VerifyVectorOfTables(" + field.name;
code += "())";
}
break;
}
default:
break;
}
break;
default:
break;
}
}
}
code += prefix + "verifier.EndTable()";
code += ";\n }\n";
code += "};\n\n";
// Generate a builder struct, with methods of the form:
// void add_name(type name) { fbb_.AddElement<type>(offset, name, default); }
code += "struct " + struct_def.name;
code += "Builder {\n flatbuffers::FlatBufferBuilder &fbb_;\n";
code += " flatbuffers::uoffset_t start_;\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) {
code += " void add_" + field.name + "(";
code += GenTypeWire(parser, field.value.type, " ", true) + field.name;
code += ") { fbb_.Add";
if (IsScalar(field.value.type.base_type)) {
code += "Element<" + GenTypeWire(parser, field.value.type, "", false);
code += ">";
} else if (IsStruct(field.value.type)) {
code += "Struct";
} else {
code += "Offset";
}
code += "(" + NumToString(field.value.offset) + ", ";
code += GenUnderlyingCast(parser, field, false, field.name);
if (IsScalar(field.value.type.base_type))
code += ", " + field.value.constant;
code += "); }\n";
}
}
code += " " + struct_def.name;
code += "Builder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) ";
code += "{ start_ = fbb_.StartTable(); }\n";
code += " " + struct_def.name + "Builder &operator=(const ";
code += struct_def.name + "Builder &);\n";
code += " flatbuffers::Offset<" + struct_def.name;
code += "> Finish() {\n auto o = flatbuffers::Offset<" + struct_def.name;
code += ">(fbb_.EndTable(start_, ";
code += NumToString(struct_def.fields.vec.size()) + "));\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated && field.required) {
code += " fbb_.Required(o, " + NumToString(field.value.offset);
code += "); // " + field.name + "\n";
}
}
code += " return o;\n }\n};\n\n";
// Generate a convenient CreateX function that uses the above builder
// to create a table in one go.
code += "inline flatbuffers::Offset<" + struct_def.name + "> Create";
code += struct_def.name;
code += "(flatbuffers::FlatBufferBuilder &_fbb";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) {
code += ",\n " + GenTypeWire(parser, field.value.type, " ", true);
code += field.name + " = ";
if (field.value.type.enum_def && IsScalar(field.value.type.base_type)) {
auto ev = field.value.type.enum_def->ReverseLookup(
static_cast<int>(StringToInt(field.value.constant.c_str())), false);
if (ev) {
code += WrapInNameSpace(parser,
field.value.type.enum_def->defined_namespace,
GenEnumVal(*field.value.type.enum_def, *ev,
opts));
} else {
code += GenUnderlyingCast(parser, field, true, field.value.constant);
}
} else {
code += field.value.constant;
}
}
}
code += ") {\n " + struct_def.name + "Builder builder_(_fbb);\n";
for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1;
size;
size /= 2) {
for (auto it = struct_def.fields.vec.rbegin();
it != struct_def.fields.vec.rend();
++it) {
auto &field = **it;
if (!field.deprecated &&
(!struct_def.sortbysize ||
size == SizeOf(field.value.type.base_type))) {
code += " builder_.add_" + field.name + "(" + field.name + ");\n";
}
}
}
code += " return builder_.Finish();\n}\n\n";
}
// Returns the method name for use with add/put calls.
static std::string GenMethod(const FieldDef &field) {
return IsScalar(field.value.type.base_type)
? MakeCamel(GenTypeBasic(field.value.type))
: (IsStruct(field.value.type) ? "Struct" : "UOffsetT");
}
HGRIDITEM InsertIdentifier(HWND hwndGV, HGRIDITEM hRoot, Type *type, size_w dwOffset, TypeDecl *typeDecl)
{
TCHAR buf[200];
GVITEM gvitem = { 0 };
HGRIDITEM hItem;
if(fShowFullType)
{
RenderType(buf, 200, type);
gvitem.pszText = buf;
}
else
{
_stprintf(buf, TEXT("%hs"), type->sym->name);
RenderType(buf, 200, type->link);
gvitem.pszText = buf;//type->sym->name;
}
gvitem.state = 0;
if(type->link && type->link->ty != typeARRAY)
gvitem.state |= GVIS_EXPANDED;
gvitem.iImage = IsStruct(type) ? 1 : 0;
//gvitem.iImage = isstruct ? 3 : 2;
if(typeDecl && typeDecl->tagList)
gvitem.iImage+=2;
gvitem.param = (ULONG_PTR)type;//typeDecl;
gvitem.mask = GVIF_TEXT|GVIF_PARAM |GVIF_STATE | GVIF_IMAGE;
hItem = GridView2_InsertUniqueChild(hwndGV, hRoot, &gvitem);
if(type->link && type->link->ty == typeARRAY)
{
FormatDataItem(hwndGV, hItem, type, dwOffset);
}
if(IsStruct(type))
{
gvitem.iSubItem = COLIDX_DATA;
gvitem.state = GVIS_READONLY;
gvitem.pszText = TEXT("{...}");
gvitem.param = 0;
gvitem.mask = GVIF_PARAM | GVIF_TEXT | GVIF_STATE;
GridView2_SetItem(hwndGV, hItem, &gvitem);
}
/*if(!fShowFullType)
{
RenderType(buf, 200, type->link);
//_stprintf(buf, TEXT("%hs"), type->sym->name);
gvitem.iSubItem = 0;//COLIDX_TYPE;
gvitem.state = GVIS_READONLY;
gvitem.pszText = buf;
gvitem.param = (UINT64)type;
gvitem.mask = GVIF_PARAM | GVIF_TEXT | GVIF_STATE;
GridView2_SetItem(hwndGV, hItem, &gvitem);
}*/
return hItem;
}
// CreateStruct
//------------------------------------------------------------------------------
Struct * ReflectionInfo::CreateStruct() const
{
ASSERT( IsStruct() );
ASSERT( !IsAbstract() );
return (Struct *)Create();
}
bool IsExportedStruct(Type *type)
{
return IsStruct(BaseType(type)) && type->sptr->exported;
}
// Generate an accessor struct, builder structs & function for a table.
static void GenTable(StructDef &struct_def, std::string *code_ptr) {
if (struct_def.generated) return;
std::string &code = *code_ptr;
// Generate an accessor struct, with methods of the form:
// type name() const { return GetField<type>(offset, defaultval); }
GenComment(struct_def.doc_comment, code_ptr);
code += "struct " + struct_def.name + " : private flatbuffers::Table";
code += " {\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) { // Deprecated fields won't be accessible.
GenComment(field.doc_comment, code_ptr, " ");
code += " " + GenTypeGet(field.value.type, " ", "const ", " *");
code += field.name + "() const { return ";
// Call a different accessor for pointers, that indirects.
code += IsScalar(field.value.type.base_type)
? "GetField<"
: (IsStruct(field.value.type) ? "GetStruct<" : "GetPointer<");
code += GenTypeGet(field.value.type, "", "const ", " *") + ">(";
code += NumToString(field.value.offset);
// Default value as second arg for non-pointer types.
if (IsScalar(field.value.type.base_type))
code += ", " + field.value.constant;
code += "); }\n";
}
}
// Generate a verifier function that can check a buffer from an untrusted
// source will never cause reads outside the buffer.
code += " bool Verify(const flatbuffers::Verifier &verifier) const {\n";
code += " return VerifyTable(verifier)";
std::string prefix = " &&\n ";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) {
code += prefix + "VerifyField<" + GenTypeSize(field.value.type);
code += ">(verifier, " + NumToString(field.value.offset);
code += " /* " + field.name + " */)";
switch (field.value.type.base_type) {
case BASE_TYPE_UNION:
code += prefix + "Verify" + field.value.type.enum_def->name;
code += "(verifier, " + field.name + "(), " + field.name + "_type())";
break;
case BASE_TYPE_STRUCT:
if (!field.value.type.struct_def->fixed) {
code += prefix + "verifier.VerifyTable(" + field.name;
code += "())";
}
break;
case BASE_TYPE_STRING:
code += prefix + "verifier.Verify(" + field.name + "())";
break;
case BASE_TYPE_VECTOR:
code += prefix + "verifier.Verify(" + field.name + "())";
switch (field.value.type.element) {
case BASE_TYPE_STRING: {
code += prefix + "verifier.VerifyVectorOfStrings(" + field.name;
code += "())";
break;
}
case BASE_TYPE_STRUCT: {
if (!field.value.type.struct_def->fixed) {
code += prefix + "verifier.VerifyVectorOfTables(" + field.name;
code += "())";
}
break;
}
default:
break;
}
break;
default:
break;
}
}
}
code += ";\n }\n";
code += "};\n\n";
// Generate a builder struct, with methods of the form:
// void add_name(type name) { fbb_.AddElement<type>(offset, name, default); }
code += "struct " + struct_def.name;
code += "Builder {\n flatbuffers::FlatBufferBuilder &fbb_;\n";
code += " flatbuffers::uoffset_t start_;\n";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) {
code += " void add_" + field.name + "(";
code += GenTypeWire(field.value.type, " ") + field.name + ") { fbb_.Add";
if (IsScalar(field.value.type.base_type))
code += "Element<" + GenTypeWire(field.value.type, "") + ">";
else if (IsStruct(field.value.type))
code += "Struct";
else
code += "Offset";
code += "(" + NumToString(field.value.offset) + ", " + field.name;
if (IsScalar(field.value.type.base_type))
code += ", " + field.value.constant;
code += "); }\n";
}
}
code += " " + struct_def.name;
code += "Builder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) ";
code += "{ start_ = fbb_.StartTable(); }\n";
code += " " + struct_def.name + "Builder &operator=(const ";
code += struct_def.name + "Builder &);\n";
code += " flatbuffers::Offset<" + struct_def.name;
code += "> Finish() { return flatbuffers::Offset<" + struct_def.name;
code += ">(fbb_.EndTable(start_, ";
code += NumToString(struct_def.fields.vec.size()) + ")); }\n};\n\n";
// Generate a convenient CreateX function that uses the above builder
// to create a table in one go.
code += "inline flatbuffers::Offset<" + struct_def.name + "> Create";
code += struct_def.name;
code += "(flatbuffers::FlatBufferBuilder &_fbb";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end();
++it) {
auto &field = **it;
if (!field.deprecated) {
code += ", " + GenTypeWire(field.value.type, " ") + field.name;
}
}
code += ") {\n " + struct_def.name + "Builder builder_(_fbb);\n";
for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1;
size;
size /= 2) {
for (auto it = struct_def.fields.vec.rbegin();
it != struct_def.fields.vec.rend();
++it) {
auto &field = **it;
if (!field.deprecated &&
(!struct_def.sortbysize ||
size == SizeOf(field.value.type.base_type))) {
code += " builder_.add_" + field.name + "(" + field.name + ");\n";
}
}
}
code += " return builder_.Finish();\n}\n\n";
}
//
// hwndGV - handle to GridView control
// hRoot - root item-handle
// type - node in the type-chain
// dwOffset - current offset
//
// returns: size of type
//
size_w RecurseType(HWND hwndGV, HGRIDITEM hRoot, Type *type, size_w dwOffset, TypeDecl *typeDecl)
{
GVITEM gvitem = { 0 };
Structure *sptr;
size_t i;
TCHAR buf[200];
if(type == 0)
return 0;
size_w dwLength = 0;
INUMTYPE switchVal = 0;//1;
HWND hwndHV = GetActiveHexView(g_hwndMain);
switch(type->ty)
{
case typeDOSTIME: case typeDOSDATE: case typeFILETIME: case typeTIMET:
dwLength = FmtData(hwndGV, hRoot, type, dwOffset, typeDecl);
break;
case typeCHAR: case typeWCHAR: case typeBYTE:
case typeWORD: case typeDWORD: case typeQWORD:
case typeFLOAT: case typeDOUBLE: case typeENUM:
dwLength = FmtData(hwndGV, hRoot, type, dwOffset, typeDecl);
break;
case typeUNION:
// evaluate the switch_is()
ExprNode *switchExpr;
if(FindTag(typeDecl->tagList, TOK_SWITCHIS, &switchExpr))
{
switchVal = Evaluate(switchExpr);
}
sptr = type->sptr;
for(i = 0; i < sptr->typeDeclList.size(); i++)
{
TypeDecl *typeDecl = sptr->typeDeclList[i];
ExprNode *caseExpr;
size_w tmpLen = 0;
if(FindTag(typeDecl->tagList, TOK_CASE, &caseExpr))
{
if(Evaluate(caseExpr) == switchVal)
tmpLen = InsertTypeGV(hwndGV, hRoot, typeDecl, dwOffset);
}
else
{
tmpLen = InsertTypeGV(hwndGV, hRoot, typeDecl, dwOffset);
}
dwLength = max(dwLength, tmpLen);
}
break;
case typeSTRUCT:
sptr = type->sptr;
for(i = 0; i < sptr->typeDeclList.size(); i++)
{
TypeDecl *typeDecl = sptr->typeDeclList[i];
dwLength += InsertTypeGV(hwndGV, hRoot, typeDecl, dwOffset + dwLength);
}
break;
case typeIDENTIFIER:
hRoot = InsertIdentifier(hwndGV, hRoot, type, dwOffset, typeDecl);
dwLength = RecurseType(hwndGV, hRoot, type->link, dwOffset, typeDecl);
break;
#if 0
if(fShowFullType)
{
RenderType(buf, 200, type);
gvitem.pszText = buf;
}
else
{
_stprintf(buf, TEXT("%hs"), type->sym->name);
gvitem.pszText = buf;//type->sym->name;
}
gvitem.state = 0;
if(type->link && type->link->ty != typeARRAY)
gvitem.state |= GVIS_EXPANDED;
gvitem.iImage = IsStruct(type) ? 1 : 0;
if(typeDecl->tagList)
gvitem.iImage+=2;
gvitem.param = (ULONG_PTR)type;//typeDecl;
gvitem.mask = GVIF_PARAM | GVIF_TEXT | GVIF_STATE | GVIF_IMAGE;
GridView2_SetItem(hwndGV, hRoot, &gvitem);
if(type->link && type->link->ty == typeARRAY)
{
FormatDataItem(hwndGV, hRoot, type, dwOffset);
}
if(IsStruct(type))
{
gvitem.iSubItem = COLIDX_DATA;
gvitem.state = GVIS_READONLY;
gvitem.pszText = TEXT("{...}");
gvitem.param = 0;
gvitem.mask = GVIF_PARAM | GVIF_TEXT | GVIF_STATE;
GridView2_SetItem(hwndGV, hRoot, &gvitem);
}
if(!fShowFullType)
{
RenderType(buf, 200, type->link);
//_stprintf(buf, TEXT("%hs"), type->sym->name);
gvitem.iSubItem = 0;//COLIDX_TYPE;
gvitem.state = GVIS_READONLY;
gvitem.pszText = buf;
gvitem.param = (UINT64)type;
gvitem.mask = GVIF_PARAM | GVIF_TEXT | GVIF_STATE;
GridView2_SetItem(hwndGV, hRoot, &gvitem);
}
dwLength = RecurseType(hwndGV, hRoot, type->link, dwOffset, typeDecl);
break;
#endif
case typeTYPEDEF:
case typeSIGNED:
case typeUNSIGNED:
case typeCONST:
// return 0;
case typePOINTER:
dwLength = RecurseType(hwndGV, hRoot, type->link, dwOffset, typeDecl);
break;
case typeARRAY:
Symbol *sym;
ExprNode *nameExpr;
if(FindTag(typeDecl->tagList, TOK_NAME, &nameExpr))
{
if((sym = LookupSymbol(globalTagSymbolList, nameExpr->str)) != 0)
{
if(sym->type && sym->type->ty == typeENUM)
;
else
sym = 0;
}
}
else
{
sym = 0;
}
UINT64 count;
count = 0;
Evaluate(GridView_GetParent(hwndGV, hRoot), type->elements, &count, dwOffset, hwndHV, hwndGV);
count &= 0xffff;
count = min(count,100);
for(i = 0; i < count; i++)
{
HGRIDITEM hItem;
TCHAR buf[164];
int len = _stprintf(buf, TEXT("[%d] "), (int)i);
if(sym)
{
Enum *eptr = sym->type->eptr;
char *s = 0;
for(size_t x = 0; x < eptr->fieldList.size(); x++)
{
if(i == eptr->fieldList[x]->val)
{
s = eptr->fieldList[i]->name->name;
}
}
_stprintf(buf + 5, TEXT("- %hs"), s);
}
gvitem.pszText = buf;
gvitem.state = GVIS_READONLY;
gvitem.iImage = 0;//rand() % 2;
gvitem.param = (ULONG_PTR)type->link;
gvitem.iSubItem = COLIDX_NAME;
gvitem.mask = GVIF_STATE|GVIF_PARAM|GVIF_TEXT;
hItem = GridView2_InsertUniqueChild(hwndGV, hRoot, &gvitem);
// used to pass '0' as typeDecl??? why?? because this is an array element we
// are recursing through!!!!
dwLength += RecurseType(hwndGV, hItem, type->link, dwOffset + dwLength, 0);//typeDecl);
}
break;
default:
break;
}
// add the 'offset' column to all items
if(hRoot)
{
_stprintf(buf, TEXT("%08x"), (DWORD)dwOffset);
gvitem.pszText = buf;
gvitem.iSubItem = COLIDX_OFFSET;
gvitem.state = 0;
gvitem.param = dwOffset;
gvitem.mask = GVIF_TEXT | GVIF_STATE | GVIF_PARAM;
GridView2_SetItem(hwndGV, hRoot, &gvitem);
// add the 'comment' column item - only do this for items that aren't array elements
if(typeDecl)// && type->ty != typeARRAY)
{
FILEREF *ref;
ref = &typeDecl->postRef;
buf[0] = '\0';
FormatWhitespace(ref, buf);
gvitem.pszText = buf;
gvitem.iSubItem = COLIDX_COMMENT;
gvitem.state = 0;
gvitem.mask = GVIF_TEXT | GVIF_STATE;
GridView2_SetItem(hwndGV, hRoot, &gvitem);
}
}
return dwLength;
}
// SetArraySize
//------------------------------------------------------------------------------
void ReflectionInfo::SetArraySize( void * array, size_t size ) const
{
ASSERT( IsStruct() );
ASSERT( !IsAbstract() );
SetArraySizeV( array, size );
}
bool IsStruct(Type *type)
{
return IsStruct(BaseType(type));
}
