inline void print_field_value(byte *value, ulint len, field_def_t *field) {
switch (field->type) {
case FT_INTERNAL:
break;
case FT_CHAR:
case FT_TEXT:
print_string((char*)value, len, field);
break;
case FT_UINT:
printf("%llu", get_uint_value(field, value));
break;
case FT_INT:
printf("%lli", get_int_value(field, value));
break;
case FT_FLOAT:
printf("%f", mach_float_read(value));
break;
case FT_DOUBLE:
printf("%lf", mach_double_read(value));
break;
case FT_DATETIME:
print_datetime(make_longlong(mach_read_from_8(value)));
break;
case FT_DATE:
print_date(mach_read_from_3(value));
break;
case FT_TIME:
print_time(mach_read_from_3(value));
break;
case FT_ENUM:
print_enum(mach_read_from_1(value), field);
break;
case FT_DECIMAL:
print_decimal(value, field);
break;
default:
printf("undef(%d)", field->type);
}
}
static void
switch_on_type(struct mlist *mlp, struct tdesc *tdp, char *format, int level)
{
boolean_t allocated = B_FALSE;
if (format == NULL) {
allocated = B_TRUE;
format = uc(mlp->name);
}
switch (tdp->type) {
case INTRINSIC:
print_intrinsic(mlp, tdp, format, level);
break;
case POINTER:
print_pointer(mlp, tdp, format, level);
break;
case ARRAY:
print_array(mlp, tdp, format, level);
break;
case FUNCTION:
print_function(mlp, tdp, format, level);
break;
case UNION:
print_union(mlp, tdp, format, level);
break;
case ENUM:
print_enum(mlp, tdp, format, level);
break;
case FORWARD:
print_forward(mlp, tdp, format, level);
break;
case TYPEOF:
print_typeof(mlp, tdp, format, level);
break;
case STRUCT:
print_struct(mlp, tdp, format, level);
break;
case VOLATILE:
print_volatile(mlp, tdp, format, level);
break;
default:
fprintf(stderr, "Switch to Unknown type\n");
error = B_TRUE;
break;
}
if (allocated)
free(format);
}
static void
dumpprint (const rpc_sym *s)
{
switch (s->type) {
case rpc_sym::STRUCT:
print_struct (s->sstruct.addr ());
break;
case rpc_sym::UNION:
print_union (s->sunion.addr ());
break;
case rpc_sym::ENUM:
print_enum (s->senum.addr ());
break;
case rpc_sym::TYPEDEF:
print_print (s->stypedef->id);
default:
break;
}
}
void print_type_decl(struct type_decl *type_decl)
{
switch (type_decl->type_def->type_type)
{
case enum_type:
print_enum(type_decl->ident, type_decl->type_def->def.enum_def);
break;
case array_type:
print_array(type_decl->ident, type_decl->type_def->def.array_def);
break;
case struct_type:
print_record(type_decl->ident, type_decl->type_def->def.record_def);
break;
case pointer_type:
print_pointer(type_decl->ident, type_decl->type_def->def.pointer_def);
break;
default:
printf("type not handled yet (in print_type_decl)\n");
}
}
void print_schema(reflection_Schema_table_t S)
{
reflection_Object_vec_t Objs;
reflection_Enum_vec_t Enums;
size_t i;
Objs = reflection_Schema_objects(S);
printf("{");
printf("\"objects\":[");
for (i = 0; i < reflection_Object_vec_len(Objs); ++i) {
if (i > 0) {
printf(",");
}
print_object(reflection_Object_vec_at(Objs, i));
}
printf("]");
Enums = reflection_Schema_enums(S);
printf(",\"enums\":[");
for (i = 0; i < reflection_Enum_vec_len(Enums); ++i) {
if (i > 0) {
printf(",");
}
print_enum(reflection_Enum_vec_at(Enums, i));
}
printf("]");
if (reflection_Schema_file_ident_is_present(S)) {
printf(",\"file_ident\":\"%s\"", reflection_Schema_file_ident(S));
}
if (reflection_Schema_file_ext_is_present(S)) {
printf(",\"file_ext\":\"%s\"", reflection_Schema_file_ext(S));
}
if (reflection_Schema_root_table_is_present(S)) {
printf(",\"root_table\":");
print_object(reflection_Schema_root_table(S));
}
printf("}\n");
}
static void
print_pattern_list (void)
{
print_enum (GES_VIDEO_TEST_PATTERN_TYPE);
}
static void
print_transition_list (void)
{
print_enum (GES_VIDEO_STANDARD_TRANSITION_TYPE_TYPE);
}
void print_properties(FILE *output, CUDFProperties *properties) {
if (properties != (CUDFProperties *)NULL) {
char sep = ' ';
fprintf(output, "property:");
for (CUDFPropertiesIterator adecl = properties->begin(); adecl != properties->end(); adecl++) {
fprintf(output, "%c %s ", sep, adecl->second->name);
switch (adecl->second->type_id) {
case pt_bool:
if (adecl->second->required)
fprintf(output, "bool");
else {
if (adecl->second->default_value->intval == 0)
fprintf(output, "bool = [false]");
else
fprintf(output, "bool = [true]");
}
break;
case pt_int:
if (adecl->second->required)
fprintf(output, "int");
else
fprintf(output, "int = [%d]", adecl->second->default_value->intval);
break;
case pt_nat:
if (adecl->second->required)
fprintf(output, "nat");
else
fprintf(output, "nat = [%d]", adecl->second->default_value->intval);
break;
case pt_posint:
if (adecl->second->required)
fprintf(output, "posint");
else
fprintf(output, "posint = [%d]", adecl->second->default_value->intval);
break;
case pt_string:
if (adecl->second->required)
fprintf(output, "string");
else {
fprintf(output, "string = [");
print_string(output, adecl->second->default_value->strval);
fprintf(output, "]");
}
break;
case pt_enum:
print_enum(output, adecl->second->enuml);
if (adecl->second->required)
fprintf(output, " = [%s]", adecl->second->default_value->strval);
break;
case pt_vpkg:
if (adecl->second->required)
fprintf(output, "vpkg");
else {
fprintf(output, "vpkg = [");
print_vpkg(output, adecl->second->default_value->vpkg);
fprintf(output, "]");
}
break;
case pt_veqpkg:
if (adecl->second->required)
fprintf(output, "veqpkg");
else {
fprintf(output, "veqpkg = [");
print_vpkg(output, adecl->second->default_value->vpkg);
fprintf(output, "]");
}
break;
case pt_vpkglist:
if (adecl->second->required)
fprintf(output, "vpkglist");
else {
fprintf(output, "vpkglist = [");
print_vpkglist(output, adecl->second->default_value->vpkglist, false);
fprintf(output, "]");
}
break;
case pt_veqpkglist:
if (adecl->second->required)
fprintf(output, "veqpkglist");
else {
fprintf(output, "veqpkglist = [");
print_vpkglist(output, adecl->second->default_value->vpkglist, false);
fprintf(output, "]");
}
break;
case pt_vpkgformula:
if (adecl->second->required)
fprintf(output, "vpkgformula");
else {
fprintf(output, "vpkgformula = [");
print_vpkgformula(output, adecl->second->default_value->vpkgformula);
fprintf(output, "]");
}
break;
case pt_none:
fprintf(output, "NONE!!");
break;
}
sep = ',';
}
fprintf(stdout, "\n\n");
}
}
void
print_eglConfig (EGLDisplay dpy, EGLConfig config)
{
EGLint val;
printf ("# EGLconfig:\n");
print_eInt (EGL_BUFFER_SIZE);
print_eInt (EGL_RED_SIZE);
print_eInt (EGL_GREEN_SIZE);
print_eInt (EGL_BLUE_SIZE);
print_eInt (EGL_LUMINANCE_SIZE);
print_eInt (EGL_ALPHA_SIZE);
print_eInt (EGL_ALPHA_MASK_SIZE);
print_eBool (EGL_BIND_TO_TEXTURE_RGB);
print_eBool (EGL_BIND_TO_TEXTURE_RGBA);
print_enum_Head (EGL_COLOR_BUFFER_TYPE);
print_enum (EGL_RGB_BUFFER);
print_enum (EGL_LUMINANCE_BUFFER);
print_enum_Foot ();
print_enum_Head (EGL_CONFIG_CAVEAT);
print_enum (EGL_NONE);
print_enum (EGL_SLOW_CONFIG);
print_enum (EGL_NON_CONFORMANT_CONFIG);
print_enum_Foot ();
print_eInt (EGL_CONFIG_ID);
print_mask_Head (EGL_CONFORMANT);
print_mask (EGL_OPENGL_ES_BIT);
print_mask (EGL_OPENGL_ES2_BIT);
print_mask (EGL_OPENVG_BIT);
print_mask (EGL_OPENGL_BIT);
print_mask_Foot ();
print_eInt (EGL_DEPTH_SIZE);
print_eInt (EGL_LEVEL);
print_eInt (EGL_MATCH_NATIVE_PIXMAP);
print_eInt (EGL_MAX_PBUFFER_WIDTH);
print_eInt (EGL_MAX_PBUFFER_HEIGHT);
print_eInt (EGL_MAX_PBUFFER_PIXELS);
print_eInt (EGL_MAX_SWAP_INTERVAL);
print_eInt (EGL_MIN_SWAP_INTERVAL);
print_eBool (EGL_NATIVE_RENDERABLE);
print_eInt (EGL_NATIVE_VISUAL_ID);
print_eInt (EGL_NATIVE_VISUAL_TYPE);
print_mask_Head (EGL_RENDERABLE_TYPE);
print_mask (EGL_OPENGL_ES_BIT);
print_mask (EGL_OPENGL_ES2_BIT);
print_mask (EGL_OPENVG_BIT);
print_mask (EGL_OPENGL_BIT);
print_mask_Foot ();
print_eInt (EGL_SAMPLE_BUFFERS);
print_eInt (EGL_SAMPLES);
print_eInt (EGL_STENCIL_SIZE);
print_mask_Head (EGL_SURFACE_TYPE);
print_mask (EGL_PBUFFER_BIT);
print_mask (EGL_PIXMAP_BIT);
print_mask (EGL_WINDOW_BIT);
print_mask (EGL_VG_COLORSPACE_LINEAR_BIT);
print_mask (EGL_VG_ALPHA_FORMAT_PRE_BIT);
print_mask (EGL_MULTISAMPLE_RESOLVE_BOX_BIT);
print_mask (EGL_SWAP_BEHAVIOR_PRESERVED_BIT);
print_mask_Foot ();
print_mask_Head (EGL_TRANSPARENT_TYPE);
print_mask (EGL_TRANSPARENT_RGB);
print_mask_Foot ();
print_eInt (EGL_TRANSPARENT_RED_VALUE);
print_eInt (EGL_TRANSPARENT_GREEN_VALUE);
print_eInt (EGL_TRANSPARENT_BLUE_VALUE);
printf ("# END\n");
}
