From b3e1f2813b4521e51e7130bd514e78b0625e16d2 Mon Sep 17 00:00:00 2001 From: Oliver Bolte Date: Fri, 4 Jun 2004 01:44:25 +0000 Subject: INTEGRATION: CWS sb18 (1.18.4); FILE MERGED 2004/05/18 15:35:26 sb 1.18.4.2: #i21150# Added new feature: published. 2004/04/08 14:33:49 sb 1.18.4.1: #i21150# Reworked dumpType. --- registry/source/regimpl.cxx | 648 +++++++++++++++++++++++--------------------- 1 file changed, 342 insertions(+), 306 deletions(-) (limited to 'registry') diff --git a/registry/source/regimpl.cxx b/registry/source/regimpl.cxx index 04435b9b2..8a44c70c8 100644 --- a/registry/source/regimpl.cxx +++ b/registry/source/regimpl.cxx @@ -2,9 +2,9 @@ * * $RCSfile: regimpl.cxx,v $ * - * $Revision: 1.18 $ + * $Revision: 1.19 $ * - * last change: $Author: rt $ $Date: 2004-03-30 16:35:14 $ + * last change: $Author: obo $ $Date: 2004-06-04 02:44:25 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -89,6 +89,11 @@ #include #endif +#include "registry/reader.hxx" +#include "registry/refltype.hxx" +#include "registry/types.h" +#include "registry/version.h" + #ifndef __REFLCNST_HXX__ #include "reflcnst.hxx" #endif @@ -127,334 +132,374 @@ sal_helper::ORealDynamicLoader* sal_helper::ODynamicLoader(c)); + } else if (s[i] >= ' ' && s[i] <= '~') { + printf("%c", static_cast< char >(c)); + } else { + printf("\\u%04X", static_cast< unsigned int >(c)); + } + } + printf("\""); +} - -//********************************************************************* -// dumpType() -// -static sal_Bool dumpType(RegistryTypeReader& reader, const OString& sIndent) +void printFieldOrReferenceFlag( + RTFieldAccess * flags, RTFieldAccess flag, char const * name, bool * first) { - sal_uInt16 i, j; - sal_Bool ret = sal_True; - const sal_Char* indent = sIndent; + if ((*flags & flag) != 0) { + if (!*first) { + printf("|"); + } + *first = false; + printf("%s", name); + *flags &= ~flag; + } +} - if (reader.isValid()) - { - fprintf(stdout, "minor version: %d\n", reader.getMinorVersion()); - fprintf(stdout, "%smajor version: %d\n", indent, reader.getMajorVersion()); - fprintf(stdout, "%s" ,indent); - switch (reader.getTypeClass()) - { - case RT_TYPE_INVALID: - fprintf(stdout, "type: 'invalid'\n"); - break; - case RT_TYPE_INTERFACE: - { - fprintf(stdout, "type: 'interface'\n"); - RTUik uik; +void printFieldOrReferenceFlags(RTFieldAccess flags) { + if (flags == 0) { + printf("none"); + } else { + bool first = true; + printFieldOrReferenceFlag( + &flags, RT_ACCESS_READONLY, "readonly", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_OPTIONAL, "optional", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_MAYBEVOID, "maybevoid", &first); + printFieldOrReferenceFlag(&flags, RT_ACCESS_BOUND, "bound", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_CONSTRAINED, "constrained", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_TRANSIENT, "transient", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_MAYBEAMBIGUOUS, "maybeambiguous", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_MAYBEDEFAULT, "maybedefault", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_REMOVEABLE, "removeable", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_ATTRIBUTE, "attribute", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_PROPERTY, "property", &first); + printFieldOrReferenceFlag(&flags, RT_ACCESS_CONST, "const", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_READWRITE, "readwrite", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_PARAMETERIZED_TYPE, "parameterized type", &first); + printFieldOrReferenceFlag( + &flags, RT_ACCESS_PUBLISHED, "published", &first); + if (flags != 0) { + if (!first) { + printf("|"); + } + printf("", static_cast< unsigned int >(flags)); + } + } +} + +void dumpType(typereg::Reader const & reader, rtl::OString const & indent) { + if (reader.isValid()) { + printf("version: %ld\n", static_cast< long >(reader.getVersion())); + printf("%sdocumentation: ", indent.getStr()); + printString(reader.getDocumentation()); + printf("\n"); + printf("%sfile name: ", indent.getStr()); + printString(reader.getFileName()); + printf("\n"); + printf("%stype class: ", indent.getStr()); + if (reader.isPublished()) { + printf("published "); + } + switch (reader.getTypeClass()) { + case RT_TYPE_INTERFACE: + printf("interface"); + break; - reader.getUik(uik); + case RT_TYPE_MODULE: + printf("module"); + break; - fprintf(stdout, "%suik: { 0x%.8x-0x%.4x-0x%.4x-0x%.8x-0x%.8x }\n", - indent, uik.m_Data1, uik.m_Data2, uik.m_Data3, uik.m_Data4, uik.m_Data5); - } + case RT_TYPE_STRUCT: + printf("struct"); + break; + + case RT_TYPE_ENUM: + printf("enum"); + break; + + case RT_TYPE_EXCEPTION: + printf("exception"); + break; + + case RT_TYPE_TYPEDEF: + printf("typedef"); + break; + + case RT_TYPE_SERVICE: + printf("service"); + break; + + case RT_TYPE_SINGLETON: + printf("singleton"); + break; + + case RT_TYPE_CONSTANTS: + printf("constants"); + break; + + default: + printf( + "", static_cast< long >(reader.getTypeClass())); + break; + } + printf("\n"); + printf("%stype name: ", indent.getStr()); + printString(reader.getTypeName()); + printf("\n"); + printf( + "%ssuper type count: %u\n", indent.getStr(), + static_cast< unsigned int >(reader.getSuperTypeCount())); + {for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) { + printf( + "%ssuper type name %u: ", indent.getStr(), + static_cast< unsigned int >(i)); + printString(reader.getSuperTypeName(i)); + printf("\n"); + }} + printf( + "%sfield count: %u\n", indent.getStr(), + static_cast< unsigned int >(reader.getFieldCount())); + {for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) { + printf( + "%sfield %u:\n", indent.getStr(), + static_cast< unsigned int >(i)); + printf("%s documentation: ", indent.getStr()); + printString(reader.getFieldDocumentation(i)); + printf("\n"); + printf("%s file name: ", indent.getStr()); + printString(reader.getFieldFileName(i)); + printf("\n"); + printf("%s flags: ", indent.getStr()); + printFieldOrReferenceFlags(reader.getFieldFlags(i)); + printf("\n"); + printf("%s name: ", indent.getStr()); + printString(reader.getFieldName(i)); + printf("\n"); + printf("%s type name: ", indent.getStr()); + printString(reader.getFieldTypeName(i)); + printf("\n"); + printf("%s value: ", indent.getStr()); + RTConstValue value(reader.getFieldValue(i)); + switch (value.m_type) { + case RT_TYPE_NONE: + printf("none"); break; - case RT_TYPE_MODULE: - fprintf(stdout, "type: 'module'\n"); + + case RT_TYPE_BOOL: + printf("boolean %s", value.m_value.aBool ? "true" : "false"); break; - case RT_TYPE_STRUCT: - fprintf(stdout, "type: 'struct'\n"); + + case RT_TYPE_BYTE: + printf( + "byte 0x%02X", + static_cast< unsigned int >(value.m_value.aByte)); break; - case RT_TYPE_ENUM: - fprintf(stdout, "type: 'enum'\n"); + + case RT_TYPE_INT16: + printf("short %d", static_cast< int >(value.m_value.aShort)); break; - case RT_TYPE_EXCEPTION: - fprintf(stdout, "type: 'exception'\n"); + + case RT_TYPE_UINT16: + printf( + "unsigned short %u", + static_cast< unsigned int >(value.m_value.aUShort)); break; - case RT_TYPE_TYPEDEF: - fprintf(stdout, "type: 'typedef'\n"); + + case RT_TYPE_INT32: + printf("long %ld", static_cast< long >(value.m_value.aLong)); break; - case RT_TYPE_SERVICE: - fprintf(stdout, "type: 'service'\n"); + + case RT_TYPE_UINT32: + printf( + "unsigned long %lu", + static_cast< unsigned long >(value.m_value.aULong)); break; - case RT_TYPE_SINGLETON: - fprintf(stdout, "type: 'singleton'\n"); + + case RT_TYPE_INT64: + // TODO: no portable way to print hyper values + printf("hyper"); break; - case RT_TYPE_CONSTANTS: - fprintf(stdout, "type: 'constants'\n"); + + case RT_TYPE_UINT64: + // TODO: no portable way to print unsigned hyper values + printf("unsigned hyper"); break; - case RT_TYPE_UNION: - fprintf(stdout, "type: 'union'\n"); + + case RT_TYPE_FLOAT: + // TODO: no portable way to print float values + printf("float"); break; - default: - fprintf(stdout, "type: \n"); + + case RT_TYPE_DOUBLE: + // TODO: no portable way to print double values + printf("double"); break; - } - fprintf(stdout, "%sname: '%s'\n", indent, OUStringToOString(reader.getTypeName(), RTL_TEXTENCODING_UTF8).getStr()); - if (reader.getTypeClass() == RT_TYPE_UNION ) - { - fprintf(stdout, "%sdiscriminant type: '%s'\n", indent, OUStringToOString(reader.getSuperTypeName(), RTL_TEXTENCODING_UTF8).getStr()); - } else - { - fprintf(stdout, "%ssuper name: '%s'\n", indent, OUStringToOString(reader.getSuperTypeName(), RTL_TEXTENCODING_UTF8).getStr()); - } - fprintf(stdout, "%sDoku: \"%s\"\n", indent, OUStringToOString(reader.getDoku(), RTL_TEXTENCODING_UTF8).getStr()); - fprintf(stdout, "%sIDL source file: \"%s\"\n", indent, OUStringToOString(reader.getFileName(), RTL_TEXTENCODING_UTF8).getStr()); - fprintf(stdout, "%snumber of fields: %d\n", indent, reader.getFieldCount()); - sal_uInt16 fieldAccess = RT_ACCESS_INVALID; - for (i = 0; i < reader.getFieldCount(); i++) - { - fprintf(stdout, "%sfield #%d:\n%s name='%s'\n%s type='%s'\n", indent, - i, indent, OUStringToOString(reader.getFieldName(i), RTL_TEXTENCODING_UTF8).getStr(), - indent, OUStringToOString(reader.getFieldType(i), RTL_TEXTENCODING_UTF8).getStr()); + case RT_TYPE_STRING: + printf("string "); + printString(value.m_value.aString); + break; - fieldAccess = reader.getFieldAccess(i); - if ( fieldAccess == RT_ACCESS_INVALID ) - { - fprintf(stdout, "%s access=INVALID\n", indent); - } - if ( (fieldAccess & RT_ACCESS_READONLY) == RT_ACCESS_READONLY ) - { - fprintf(stdout, "%s access=READONLY\n", indent); - } - if ( (fieldAccess & RT_ACCESS_READWRITE) == RT_ACCESS_READWRITE ) - { - fprintf(stdout, "%s access=READWRITE\n", indent); - } - if ( (fieldAccess & RT_ACCESS_OPTIONAL) == RT_ACCESS_OPTIONAL ) - { - fprintf(stdout, "%s access=OPTIONAL\n", indent); - } - if ( (fieldAccess & RT_ACCESS_MAYBEVOID) == RT_ACCESS_MAYBEVOID ) - { - fprintf(stdout, "%s access=MAYBEVOID\n", indent); - } - if ( (fieldAccess & RT_ACCESS_BOUND) == RT_ACCESS_BOUND ) - { - fprintf(stdout, "%s access=BOUND\n", indent); - } - if ( (fieldAccess & RT_ACCESS_CONSTRAINED) == RT_ACCESS_CONSTRAINED ) - { - fprintf(stdout, "%s access=CONSTRAINED\n", indent); - } - if ( (fieldAccess & RT_ACCESS_TRANSIENT) == RT_ACCESS_TRANSIENT ) - { - fprintf(stdout, "%s access=TRANSIENT\n", indent); - } - if ( (fieldAccess & RT_ACCESS_MAYBEAMBIGUOUS) == RT_ACCESS_MAYBEAMBIGUOUS ) - { - fprintf(stdout, "%s access=MAYBEAMBIGUOUS\n", indent); - } - if ( (fieldAccess & RT_ACCESS_MAYBEDEFAULT) == RT_ACCESS_MAYBEDEFAULT ) - { - fprintf(stdout, "%s access=MAYBEDEFAULT\n", indent); - } - if ( (fieldAccess & RT_ACCESS_REMOVEABLE) == RT_ACCESS_REMOVEABLE ) - { - fprintf(stdout, "%s access=REMOVEABLE\n", indent); - } - if ( (fieldAccess & RT_ACCESS_DEFAULT) == RT_ACCESS_DEFAULT ) - { - fprintf(stdout, "%s access=DEFAULT\n", indent); - } - if ( (fieldAccess & RT_ACCESS_CONST) == RT_ACCESS_CONST ) - { - fprintf(stdout, "%s access=CONST\n", indent); + default: + printf("", static_cast< long >(value.m_type)); + break; } + printf("\n"); + }} + printf( + "%smethod count: %u\n", indent.getStr(), + static_cast< unsigned int >(reader.getMethodCount())); + {for (sal_uInt16 i = 0; i < reader.getMethodCount(); ++i) { + printf( + "%smethod %u:\n", indent.getStr(), + static_cast< unsigned int >(i)); + printf("%s documentation: ", indent.getStr()); + printString(reader.getMethodDocumentation(i)); + printf("\n"); + printf("%s flags: ", indent.getStr()); + switch (reader.getMethodFlags(i)) { + case RT_MODE_ONEWAY: + printf("oneway"); + break; - RTConstValue constVal = reader.getFieldConstValue(i); - - if ( constVal.m_type != RT_TYPE_NONE ) - { - fprintf(stdout, "%s value = ", indent); - - switch (constVal.m_type) - { - case RT_TYPE_BOOL: - if (constVal.m_value.aBool) - fprintf(stdout, "TRUE"); - else - fprintf(stdout, "FALSE"); - break; - case RT_TYPE_BYTE: - fprintf(stdout, "%d", (int)constVal.m_value.aByte); - break; - case RT_TYPE_INT16: - fprintf(stdout, "%d", constVal.m_value.aShort); - break; - case RT_TYPE_UINT16: - fprintf(stdout, "%u", constVal.m_value.aUShort); - break; - case RT_TYPE_INT32: - fprintf(stdout, "%d", constVal.m_value.aLong); - break; - case RT_TYPE_UINT32: - fprintf(stdout, "%u", constVal.m_value.aULong); - break; - case RT_TYPE_INT64: - { - ::rtl::OString tmp( OString::valueOf(constVal.m_value.aHyper) ); - fprintf(stdout, "%s", tmp.getStr()); - } - break; - case RT_TYPE_UINT64: - { - OString tmp( OString::valueOf((sal_Int64)constVal.m_value.aUHyper) ); - fprintf(stdout, "%s", tmp.getStr()); - } - break; - case RT_TYPE_FLOAT: - { - ::rtl::OString tmp( OString::valueOf(constVal.m_value.aFloat) ); - fprintf(stdout, "%s", tmp.getStr()); - } - break; - case RT_TYPE_DOUBLE: - { - ::rtl::OString tmp( OString::valueOf(constVal.m_value.aDouble) ); - fprintf(stdout, "%s", tmp.getStr()); - } - break; - case RT_TYPE_STRING: - fprintf(stdout, "%s", OUStringToOString(constVal.m_value.aString, RTL_TEXTENCODING_UTF8).getStr()); - break; - default: - break; - } - } + case RT_MODE_TWOWAY: + printf("synchronous"); + break; - fprintf(stdout, "\n%s Doku: \"%s\"", indent, OUStringToOString(reader.getFieldDoku(i), RTL_TEXTENCODING_UTF8).getStr()); - fprintf(stdout, "\n%s IDL source file: \"%s\"\n", indent, OUStringToOString(reader.getFieldFileName(i), RTL_TEXTENCODING_UTF8).getStr()); - } + case RT_MODE_ATTRIBUTE_GET: + printf("attribute get"); + break; - fprintf(stdout, "%snumber of methods: %d\n", indent, reader.getMethodCount()); - for (i = 0; i < reader.getMethodCount(); i++) - { - fprintf(stdout, "%smethod #%d: ", indent, i); + case RT_MODE_ATTRIBUTE_SET: + printf("attribute set"); + break; - RTMethodMode mode = reader.getMethodMode(i); - switch (mode) + default: + printf( + "", + static_cast< long >(reader.getMethodFlags(i))); + break; + } + printf("\n"); + printf("%s name: ", indent.getStr()); + printString(reader.getMethodName(i)); + printf("\n"); + printf("%s return type name: ", indent.getStr()); + printString(reader.getMethodReturnTypeName(i)); + printf("\n"); + printf( + "%s parameter count: %u\n", indent.getStr(), + static_cast< unsigned int >(reader.getMethodParameterCount(i))); + {for (sal_uInt32 j = 0; j < reader.getMethodParameterCount(i); ++j) { - case RT_MODE_INVALID: - fprintf(stdout, " "); + printf( + "%s parameter %u:\n", indent.getStr(), + static_cast< unsigned int >(j)); + printf("%s flags: ", indent.getStr()); + RTParamMode flags = reader.getMethodParameterFlags(i, j); + bool rest = (flags & RT_PARAM_REST) != 0; + switch (flags & ~RT_PARAM_REST) { + case RT_PARAM_IN: + printf("in"); break; - case RT_MODE_ONEWAY: - fprintf(stdout, "[oneway] "); - break; - case RT_MODE_ONEWAY_CONST: - fprintf(stdout, "[oneway, const] "); - break; - case RT_MODE_TWOWAY: + + case RT_PARAM_OUT: + printf("out"); break; - case RT_MODE_TWOWAY_CONST: - fprintf(stdout, "[const] "); + + case RT_PARAM_INOUT: + printf("inout"); break; + default: - fprintf( - stdout, " ", static_cast< int >(mode)); + printf("", static_cast< long >(flags)); + rest = false; break; - } - - fprintf(stdout, "%s %s(", - OUStringToOString(reader.getMethodReturnType(i), RTL_TEXTENCODING_UTF8).getStr(), - OUStringToOString(reader.getMethodName(i), RTL_TEXTENCODING_UTF8).getStr()); - - for (j = 0; j < reader.getMethodParamCount(i); j++) - { - RTParamMode mode = reader.getMethodParamMode(i, j); - bool rest = (mode & RT_PARAM_REST) != 0; - switch (mode & ~RT_PARAM_REST) - { - case RT_PARAM_INVALID: - fprintf(stdout, " "); - break; - case RT_PARAM_IN: - fprintf(stdout, "[in] "); - break; - case RT_PARAM_OUT: - fprintf(stdout, "[out] "); - break; - case RT_PARAM_INOUT: - fprintf(stdout, "[inout] "); - break; - default: - fprintf( - stdout, " ", - static_cast< int >(mode)); - break; } - - fprintf(stdout, "%s%s %s", - OUStringToOString(reader.getMethodParamType(i, j), RTL_TEXTENCODING_UTF8).getStr(), - rest ? "..." : "", - OUStringToOString(reader.getMethodParamName(i, j), RTL_TEXTENCODING_UTF8).getStr()); - - if (j != reader.getMethodParamCount(i) - 1) - fprintf(stdout, ", "); - } - - fprintf(stdout, ") "); - - if (reader.getMethodExcCount(i)) - { - fprintf(stdout, "raises "); - for (j = 0; j < reader.getMethodExcCount(i); j++) - { - fprintf(stdout, "%s", - OUStringToOString(reader.getMethodExcType(i, j), RTL_TEXTENCODING_UTF8).getStr()); - if (j != reader.getMethodExcCount(i) - 1) - fprintf(stdout, ", "); + if (rest) { + printf("|rest"); } - } + printf("\n"); + printf("%s name: ", indent.getStr()); + printString(reader.getMethodParameterName(i, j)); + printf("\n"); + printf("%s type name: ", indent.getStr()); + printString(reader.getMethodParameterTypeName(i, j)); + printf("\n"); + }} + printf( + "%s exception count: %u\n", indent.getStr(), + static_cast< unsigned int >(reader.getMethodExceptionCount(i))); + {for (sal_uInt32 j = 0; j < reader.getMethodExceptionCount(i); ++j) + { + printf( + "%s exception type name %u: ", indent.getStr(), + static_cast< unsigned int >(j)); + printString(reader.getMethodExceptionTypeName(i, j)); + printf("\n"); + }} + }} + printf( + "%sreference count: %u\n", indent.getStr(), + static_cast< unsigned int >(reader.getReferenceCount())); + {for (sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i) { + printf( + "%sreference %u:\n", indent.getStr(), + static_cast< unsigned int >(i)); + printf("%s documentation: ", indent.getStr()); + printString(reader.getReferenceDocumentation(i)); + printf("\n"); + printf("%s flags: ", indent.getStr()); + printFieldOrReferenceFlags(reader.getReferenceFlags(i)); + printf("\n"); + printf("%s sort: ", indent.getStr()); + switch (reader.getReferenceSort(i)) { + case RT_REF_SUPPORTS: + printf("supports"); + break; - fprintf(stdout, "\n%s Doku: \"%s\"\n", indent, - OUStringToOString(reader.getMethodDoku(i), RTL_TEXTENCODING_UTF8).getStr()); - } + case RT_REF_EXPORTS: + printf("exports"); + break; - fprintf(stdout, "%snumber of references: %d\n", indent, reader.getReferenceCount()); - for (i = 0; i < reader.getReferenceCount(); i++) - { - fprintf(stdout, "%sreference #%d:\n%s name='%s'\n", indent, i, indent, - OUStringToOString(reader.getReferenceName(i), RTL_TEXTENCODING_UTF8).getStr()); - switch (reader.getReferenceType(i)) - { - case RT_REF_INVALID: - fprintf(stdout, "%s type=INVALID\n", indent); - break; - case RT_REF_SUPPORTS: - fprintf(stdout, "%s type=supported interface\n", indent); - break; - case RT_REF_OBSERVES: - fprintf(stdout, "%s type=observed interface\n", indent); - break; - case RT_REF_EXPORTS: - fprintf(stdout, "%s type=exported service\n", indent); - break; - case RT_REF_NEEDS: - fprintf(stdout, "%s type=needed service\n", indent); - break; - default: - fprintf(stdout, "%s type=\n", indent); - break; - } - if (reader.getReferenceAccess(i) == RT_ACCESS_OPTIONAL) - { - fprintf(stdout, "%s access=optional\n", indent); - } + case RT_REF_TYPE_PARAMETER: + printf("type parameter"); + break; - fprintf(stdout, "%s Doku: \"%s\"\n", indent, - OUStringToOString(reader.getReferenceDoku(i), RTL_TEXTENCODING_UTF8).getStr()); - } - } - else - { - ret = sal_False; + default: + printf( + "", + static_cast< long >(reader.getReferenceSort(i))); + break; + } + printf("\n"); + printf("%s type name: ", indent.getStr()); + printString(reader.getReferenceTypeName(i)); + printf("\n"); + }} + } else { + printf("\n"); } - - return ret; } +} //********************************************************************* // ORegistry() @@ -1855,19 +1900,10 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_ fprintf(stdout, "%sValue: Type = RG_VALUETYPE_BINARY\n", indent); fprintf(stdout, "%s Size = %d\n", indent, valueSize); fprintf(stdout, "%s Data = ", indent); - - RegistryTypeReader_Api* pReaderApi; - - pReaderApi = initRegistryTypeReader_Api(); - - RegistryTypeReader reader(pReaderApi, pBuffer, valueSize, sal_False); - - sIndent += " "; - if (!dumpType(reader, sIndent)) - { - fprintf(stdout, "\n"); - } - + dumpType( + typereg::Reader( + pBuffer, valueSize, false, TYPEREG_VERSION_1), + sIndent + " "); } break; case 5: -- cgit v1.2.3