fwupd_guid_to_string: 174| 339|{ 175| 339| fwupd_guid_native_t gnat; 176| | 177| 339| g_return_val_if_fail(guid != NULL, NULL); ------------------ | | 643| 339| G_STMT_START { \ | | ------------------ | | | | 874| 339|#define G_STMT_START do | | ------------------ | | 644| 339| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 339|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 339| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 339|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 339| int _g_boolean_var_; \ | | | | | | 1018| 339| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 339, False: 0] | | | | | | ------------------ | | | | | | 1019| 339| _g_boolean_var_ = 1; \ | | | | | | 1020| 339| else \ | | | | | | 1021| 339| _g_boolean_var_ = 0; \ | | | | | | 1022| 339| _g_boolean_var_; \ | | | | | | 1023| 339|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 339, False: 0] | | | | ------------------ | | ------------------ | | 645| 339| { } \ | | 646| 339| else \ | | 647| 339| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 303| 0|#define G_LOG_DOMAIN ((gchar*) 0) | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 339| } G_STMT_END | | ------------------ | | | | 882| 339|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 339] | | | | ------------------ | | ------------------ ------------------ 178| | 179| | /* copy to avoid issues with aligning */ 180| 339| memcpy(&gnat, guid, sizeof(gnat)); /* nocheck:blocked */ 181| | 182| | /* mixed is bizaar, but specified as the DCE encoding */ 183| 339| if (flags & FWUPD_GUID_FLAG_MIXED_ENDIAN) { ------------------ | Branch (183:6): [True: 0, False: 339] ------------------ 184| 0| return g_strdup_printf("%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", 185| 0| (guint)GUINT32_FROM_LE(gnat.a), /* nocheck:blocked */ ------------------ | | 390| 0|#define GUINT32_FROM_LE(val) (GUINT32_TO_LE (val)) | | ------------------ | | | | 165| 0|#define GUINT32_TO_LE(val) ((guint32) (val)) | | ------------------ ------------------ 186| 0| (guint)GUINT16_FROM_LE(gnat.b), /* nocheck:blocked */ ------------------ | | 386| 0|#define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val)) | | ------------------ | | | | 160| 0|#define GUINT16_TO_LE(val) ((guint16) (val)) | | ------------------ ------------------ 187| 0| (guint)GUINT16_FROM_LE(gnat.c), /* nocheck:blocked */ ------------------ | | 386| 0|#define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val)) | | ------------------ | | | | 160| 0|#define GUINT16_TO_LE(val) ((guint16) (val)) | | ------------------ ------------------ 188| 0| (guint)GUINT16_FROM_BE(gnat.d), /* nocheck:blocked */ ------------------ | | 388| 0|#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val)) | | ------------------ | | | | 162| 0|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 351| 0|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | | | ------------------ | | | | | | | | 191| 0|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | | | 192| 0| (guint16) ((guint16) (val) >> 8) | \ | | | | | | | | 193| 0| (guint16) ((guint16) (val) << 8))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 189| 0| gnat.e[0], 190| 0| gnat.e[1], 191| 0| gnat.e[2], 192| 0| gnat.e[3], 193| 0| gnat.e[4], 194| 0| gnat.e[5]); 195| 0| } 196| 339| return g_strdup_printf("%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x", 197| 339| (guint)GUINT32_FROM_BE(gnat.a), /* nocheck:blocked */ ------------------ | | 392| 339|#define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val)) | | ------------------ | | | | 167| 339|#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 353| 339|# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86_64 (val)) | | | | | | ------------------ | | | | | | | | 331| 339| (G_GNUC_EXTENSION \ | | | | | | | | ------------------ | | | | | | | | | | 54| 339|#define G_GNUC_EXTENSION __extension__ | | | | | | | | ------------------ | | | | | | | | 332| 339| ({ guint32 __v, __x = ((guint32) (val)); \ | | | | | | | | 333| 339| if (__builtin_constant_p (__x)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (333:10): [True: 0, False: 339] | | | | | | | | ------------------ | | | | | | | | 334| 339| __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); \ | | | | | | | | ------------------ | | | | | | | | | | 195| 0|#define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \ | | | | | | | | | | 196| 0| (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \ | | | | | | | | | | 197| 0| (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | \ | | | | | | | | | | 198| 0| (((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | \ | | | | | | | | | | 199| 0| (((guint32) (val) & (guint32) 0xff000000U) >> 24))) | | | | | | | | ------------------ | | | | | | | | 335| 339| else \ | | | | | | | | 336| 339| __asm__ ("bswapl %0" \ | | | | | | | | 337| 339| : "=r" (__v) \ | | | | | | | | 338| 339| : "0" (__x)); \ | | | | | | | | 339| 339| __v; })) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 198| 339| (guint)GUINT16_FROM_BE(gnat.b), /* nocheck:blocked */ ------------------ | | 388| 339|#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val)) | | ------------------ | | | | 162| 339|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 351| 339|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | | | ------------------ | | | | | | | | 191| 339|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | | | 192| 339| (guint16) ((guint16) (val) >> 8) | \ | | | | | | | | 193| 339| (guint16) ((guint16) (val) << 8))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 199| 339| (guint)GUINT16_FROM_BE(gnat.c), /* nocheck:blocked */ ------------------ | | 388| 339|#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val)) | | ------------------ | | | | 162| 339|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 351| 339|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | | | ------------------ | | | | | | | | 191| 339|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | | | 192| 339| (guint16) ((guint16) (val) >> 8) | \ | | | | | | | | 193| 339| (guint16) ((guint16) (val) << 8))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 339| (guint)GUINT16_FROM_BE(gnat.d), /* nocheck:blocked */ ------------------ | | 388| 339|#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val)) | | ------------------ | | | | 162| 339|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 351| 339|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | | | ------------------ | | | | | | | | 191| 339|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | | | 192| 339| (guint16) ((guint16) (val) >> 8) | \ | | | | | | | | 193| 339| (guint16) ((guint16) (val) << 8))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 201| 339| gnat.e[0], 202| 339| gnat.e[1], 203| 339| gnat.e[2], 204| 339| gnat.e[3], 205| 339| gnat.e[4], 206| 339| gnat.e[5]); 207| 339|} fwupd_guid_from_string: 228| 197|{ 229| 197| fwupd_guid_native_t gu = {0x0}; 230| 197| gboolean mixed_endian = flags & FWUPD_GUID_FLAG_MIXED_ENDIAN; 231| 197| guint64 tmp; 232| 197| g_auto(GStrv) split = NULL; ------------------ | | 1166| 197|#define g_auto(TypeName) _GLIB_CLEANUP(_GLIB_AUTO_FUNC_NAME(TypeName)) TypeName | | ------------------ | | | | 1129| 197|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 233| | 234| 197| g_return_val_if_fail(guidstr != NULL, FALSE); ------------------ | | 643| 197| G_STMT_START { \ | | ------------------ | | | | 874| 197|#define G_STMT_START do | | ------------------ | | 644| 197| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 197|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 197| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 197|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 197| int _g_boolean_var_; \ | | | | | | 1018| 197| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 197, False: 0] | | | | | | ------------------ | | | | | | 1019| 197| _g_boolean_var_ = 1; \ | | | | | | 1020| 197| else \ | | | | | | 1021| 197| _g_boolean_var_ = 0; \ | | | | | | 1022| 197| _g_boolean_var_; \ | | | | | | 1023| 197|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 197, False: 0] | | | | ------------------ | | ------------------ | | 645| 197| { } \ | | 646| 197| else \ | | 647| 197| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 303| 0|#define G_LOG_DOMAIN ((gchar*) 0) | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 197| } G_STMT_END | | ------------------ | | | | 882| 197|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 197] | | | | ------------------ | | ------------------ ------------------ 235| 197| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 197| G_STMT_START { \ | | ------------------ | | | | 874| 197|#define G_STMT_START do | | ------------------ | | 644| 197| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 197|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 197| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 197|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 197| int _g_boolean_var_; \ | | | | | | 1018| 394| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 197, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 197| _g_boolean_var_ = 1; \ | | | | | | 1020| 197| else \ | | | | | | 1021| 197| _g_boolean_var_ = 0; \ | | | | | | 1022| 197| _g_boolean_var_; \ | | | | | | 1023| 197|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 197, False: 0] | | | | ------------------ | | ------------------ | | 645| 197| { } \ | | 646| 197| else \ | | 647| 197| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 303| 0|#define G_LOG_DOMAIN ((gchar*) 0) | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 197| } G_STMT_END | | ------------------ | | | | 882| 197|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 197] | | | | ------------------ | | ------------------ ------------------ 236| | 237| | /* split into sections */ 238| 197| if (strlen(guidstr) != 36) { ------------------ | Branch (238:6): [True: 109, False: 88] ------------------ 239| 109| g_set_error_literal(error, 240| 109| FWUPD_ERROR, ------------------ | | 15| 109|#define FWUPD_ERROR fwupd_error_quark() ------------------ 241| 109| FWUPD_ERROR_INVALID_DATA, 242| 109| "GUID is not valid format"); 243| 109| return FALSE; ------------------ | | 814| 109|#define FALSE (0) ------------------ 244| 109| } 245| 88| split = g_strsplit(guidstr, "-", 5); 246| 88| if (g_strv_length(split) != 5) { ------------------ | Branch (246:6): [True: 4, False: 84] ------------------ 247| 4| g_set_error_literal(error, 248| 4| FWUPD_ERROR, ------------------ | | 15| 4|#define FWUPD_ERROR fwupd_error_quark() ------------------ 249| 4| FWUPD_ERROR_INVALID_DATA, 250| 4| "GUID is not valid format, no dashes"); 251| 4| return FALSE; ------------------ | | 814| 4|#define FALSE (0) ------------------ 252| 4| } 253| 84| if (strlen(split[0]) != 8 || strlen(split[1]) != 4 || strlen(split[2]) != 4 || ------------------ | Branch (253:6): [True: 5, False: 79] | Branch (253:31): [True: 2, False: 77] | Branch (253:56): [True: 4, False: 73] ------------------ 254| 73| strlen(split[3]) != 4 || strlen(split[4]) != 12) { ------------------ | Branch (254:6): [True: 4, False: 69] | Branch (254:31): [True: 0, False: 69] ------------------ 255| 15| g_set_error_literal(error, 256| 15| FWUPD_ERROR, ------------------ | | 15| 15|#define FWUPD_ERROR fwupd_error_quark() ------------------ 257| 15| FWUPD_ERROR_INVALID_DATA, 258| 15| "GUID is not valid format, not GUID"); 259| 15| return FALSE; ------------------ | | 814| 15|#define FALSE (0) ------------------ 260| 15| } 261| | 262| | /* parse */ 263| 69| if (!g_ascii_string_to_unsigned(split[0], 16, 0, 0xffffffff, &tmp, error)) ------------------ | Branch (263:6): [True: 6, False: 63] ------------------ 264| 6| return FALSE; ------------------ | | 814| 6|#define FALSE (0) ------------------ 265| 63| gu.a = mixed_endian ? GUINT32_TO_LE(tmp) : GUINT32_TO_BE(tmp); /* nocheck:blocked */ ------------------ | | 165| 0|#define GUINT32_TO_LE(val) ((guint32) (val)) ------------------ gu.a = mixed_endian ? GUINT32_TO_LE(tmp) : GUINT32_TO_BE(tmp); /* nocheck:blocked */ ------------------ | | 167| 126|#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val)) | | ------------------ | | | | 353| 63|# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86_64 (val)) | | | | ------------------ | | | | | | 331| 63| (G_GNUC_EXTENSION \ | | | | | | ------------------ | | | | | | | | 54| 63|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 332| 63| ({ guint32 __v, __x = ((guint32) (val)); \ | | | | | | 333| 63| if (__builtin_constant_p (__x)) \ | | | | | | ------------------ | | | | | | | Branch (333:10): [True: 0, False: 63] | | | | | | ------------------ | | | | | | 334| 63| __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); \ | | | | | | ------------------ | | | | | | | | 195| 0|#define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \ | | | | | | | | 196| 0| (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \ | | | | | | | | 197| 0| (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | \ | | | | | | | | 198| 0| (((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | \ | | | | | | | | 199| 0| (((guint32) (val) & (guint32) 0xff000000U) >> 24))) | | | | | | ------------------ | | | | | | 335| 63| else \ | | | | | | 336| 63| __asm__ ("bswapl %0" \ | | | | | | 337| 63| : "=r" (__v) \ | | | | | | 338| 63| : "0" (__x)); \ | | | | | | 339| 63| __v; })) | | | | ------------------ | | ------------------ ------------------ | Branch (265:9): [True: 0, False: 63] ------------------ 266| 63| if (!g_ascii_string_to_unsigned(split[1], 16, 0, 0xffff, &tmp, error)) ------------------ | Branch (266:6): [True: 2, False: 61] ------------------ 267| 2| return FALSE; ------------------ | | 814| 2|#define FALSE (0) ------------------ 268| 61| gu.b = mixed_endian ? GUINT16_TO_LE(tmp) : GUINT16_TO_BE(tmp); /* nocheck:blocked */ ------------------ | | 160| 0|#define GUINT16_TO_LE(val) ((guint16) (val)) ------------------ gu.b = mixed_endian ? GUINT16_TO_LE(tmp) : GUINT16_TO_BE(tmp); /* nocheck:blocked */ ------------------ | | 162| 122|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | ------------------ | | | | 351| 61|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | ------------------ | | | | | | 191| 61|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | 192| 61| (guint16) ((guint16) (val) >> 8) | \ | | | | | | 193| 61| (guint16) ((guint16) (val) << 8))) | | | | ------------------ | | ------------------ ------------------ | Branch (268:9): [True: 0, False: 61] ------------------ 269| 61| if (!g_ascii_string_to_unsigned(split[2], 16, 0, 0xffff, &tmp, error)) ------------------ | Branch (269:6): [True: 3, False: 58] ------------------ 270| 3| return FALSE; ------------------ | | 814| 3|#define FALSE (0) ------------------ 271| 58| gu.c = mixed_endian ? GUINT16_TO_LE(tmp) : GUINT16_TO_BE(tmp); /* nocheck:blocked */ ------------------ | | 160| 0|#define GUINT16_TO_LE(val) ((guint16) (val)) ------------------ gu.c = mixed_endian ? GUINT16_TO_LE(tmp) : GUINT16_TO_BE(tmp); /* nocheck:blocked */ ------------------ | | 162| 116|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | ------------------ | | | | 351| 58|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | ------------------ | | | | | | 191| 58|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | 192| 58| (guint16) ((guint16) (val) >> 8) | \ | | | | | | 193| 58| (guint16) ((guint16) (val) << 8))) | | | | ------------------ | | ------------------ ------------------ | Branch (271:9): [True: 0, False: 58] ------------------ 272| 58| if (!g_ascii_string_to_unsigned(split[3], 16, 0, 0xffff, &tmp, error)) ------------------ | Branch (272:6): [True: 4, False: 54] ------------------ 273| 4| return FALSE; ------------------ | | 814| 4|#define FALSE (0) ------------------ 274| 54| gu.d = GUINT16_TO_BE(tmp); /* nocheck:blocked */ ------------------ | | 162| 54|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | ------------------ | | | | 351| 54|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | ------------------ | | | | | | 191| 54|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | 192| 54| (guint16) ((guint16) (val) >> 8) | \ | | | | | | 193| 54| (guint16) ((guint16) (val) << 8))) | | | | ------------------ | | ------------------ ------------------ 275| 343| for (guint i = 0; i < 6; i++) { ------------------ | Branch (275:20): [True: 297, False: 46] ------------------ 276| 297| gchar buffer[3] = {0x0}; 277| 297| memcpy(buffer, split[4] + (i * 2), 2); /* nocheck:blocked */ 278| 297| if (!g_ascii_string_to_unsigned(buffer, 16, 0, 0xff, &tmp, error)) ------------------ | Branch (278:7): [True: 8, False: 289] ------------------ 279| 8| return FALSE; ------------------ | | 814| 8|#define FALSE (0) ------------------ 280| 289| gu.e[i] = tmp; 281| 289| } 282| 46| if (guid != NULL) ------------------ | Branch (282:6): [True: 46, False: 0] ------------------ 283| 46| memcpy(guid, &gu, sizeof(gu)); /* nocheck:blocked */ 284| | 285| | /* success */ 286| 46| return TRUE; ------------------ | | 818| 46|#define TRUE (!FALSE) | | ------------------ | | | | 814| 46|#define FALSE (0) | | ------------------ ------------------ 287| 54|} fwupd_error_to_string: 26| 22|{ 27| 22| if (error == FWUPD_ERROR_INTERNAL) ------------------ | Branch (27:6): [True: 1, False: 21] ------------------ 28| 1| return FWUPD_DBUS_INTERFACE ".Internal"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 29| 21| if (error == FWUPD_ERROR_VERSION_NEWER) ------------------ | Branch (29:6): [True: 1, False: 20] ------------------ 30| 1| return FWUPD_DBUS_INTERFACE ".VersionNewer"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 31| 20| if (error == FWUPD_ERROR_VERSION_SAME) ------------------ | Branch (31:6): [True: 1, False: 19] ------------------ 32| 1| return FWUPD_DBUS_INTERFACE ".VersionSame"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 33| 19| if (error == FWUPD_ERROR_ALREADY_PENDING) ------------------ | Branch (33:6): [True: 1, False: 18] ------------------ 34| 1| return FWUPD_DBUS_INTERFACE ".AlreadyPending"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 35| 18| if (error == FWUPD_ERROR_AUTH_FAILED) ------------------ | Branch (35:6): [True: 1, False: 17] ------------------ 36| 1| return FWUPD_DBUS_INTERFACE ".AuthFailed"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 37| 17| if (error == FWUPD_ERROR_READ) ------------------ | Branch (37:6): [True: 1, False: 16] ------------------ 38| 1| return FWUPD_DBUS_INTERFACE ".Read"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 39| 16| if (error == FWUPD_ERROR_WRITE) ------------------ | Branch (39:6): [True: 1, False: 15] ------------------ 40| 1| return FWUPD_DBUS_INTERFACE ".Write"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 41| 15| if (error == FWUPD_ERROR_INVALID_FILE) ------------------ | Branch (41:6): [True: 1, False: 14] ------------------ 42| 1| return FWUPD_DBUS_INTERFACE ".InvalidFile"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 43| 14| if (error == FWUPD_ERROR_NOT_FOUND) ------------------ | Branch (43:6): [True: 1, False: 13] ------------------ 44| 1| return FWUPD_DBUS_INTERFACE ".NotFound"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 45| 13| if (error == FWUPD_ERROR_NOTHING_TO_DO) ------------------ | Branch (45:6): [True: 1, False: 12] ------------------ 46| 1| return FWUPD_DBUS_INTERFACE ".NothingToDo"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 47| 12| if (error == FWUPD_ERROR_NOT_SUPPORTED) ------------------ | Branch (47:6): [True: 1, False: 11] ------------------ 48| 1| return FWUPD_DBUS_INTERFACE ".NotSupported"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 49| 11| if (error == FWUPD_ERROR_SIGNATURE_INVALID) ------------------ | Branch (49:6): [True: 1, False: 10] ------------------ 50| 1| return FWUPD_DBUS_INTERFACE ".SignatureInvalid"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 51| 10| if (error == FWUPD_ERROR_AC_POWER_REQUIRED) ------------------ | Branch (51:6): [True: 1, False: 9] ------------------ 52| 1| return FWUPD_DBUS_INTERFACE ".AcPowerRequired"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 53| 9| if (error == FWUPD_ERROR_PERMISSION_DENIED) ------------------ | Branch (53:6): [True: 1, False: 8] ------------------ 54| 1| return FWUPD_DBUS_INTERFACE ".PermissionDenied"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 55| 8| if (error == FWUPD_ERROR_BROKEN_SYSTEM) ------------------ | Branch (55:6): [True: 1, False: 7] ------------------ 56| 1| return FWUPD_DBUS_INTERFACE ".BrokenSystem"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 57| 7| if (error == FWUPD_ERROR_BATTERY_LEVEL_TOO_LOW) ------------------ | Branch (57:6): [True: 1, False: 6] ------------------ 58| 1| return FWUPD_DBUS_INTERFACE ".BatteryLevelTooLow"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 59| 6| if (error == FWUPD_ERROR_NEEDS_USER_ACTION) ------------------ | Branch (59:6): [True: 1, False: 5] ------------------ 60| 1| return FWUPD_DBUS_INTERFACE ".NeedsUserAction"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 61| 5| if (error == FWUPD_ERROR_AUTH_EXPIRED) ------------------ | Branch (61:6): [True: 1, False: 4] ------------------ 62| 1| return FWUPD_DBUS_INTERFACE ".AuthExpired"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 63| 4| if (error == FWUPD_ERROR_INVALID_DATA) ------------------ | Branch (63:6): [True: 1, False: 3] ------------------ 64| 1| return FWUPD_DBUS_INTERFACE ".InvalidData"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 65| 3| if (error == FWUPD_ERROR_TIMED_OUT) ------------------ | Branch (65:6): [True: 1, False: 2] ------------------ 66| 1| return FWUPD_DBUS_INTERFACE ".TimedOut"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 67| 2| if (error == FWUPD_ERROR_BUSY) ------------------ | Branch (67:6): [True: 1, False: 1] ------------------ 68| 1| return FWUPD_DBUS_INTERFACE ".Busy"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 69| 1| if (error == FWUPD_ERROR_NOT_REACHABLE) ------------------ | Branch (69:6): [True: 1, False: 0] ------------------ 70| 1| return FWUPD_DBUS_INTERFACE ".NotReachable"; ------------------ | | 30| 1|#define FWUPD_DBUS_INTERFACE "org.freedesktop.fwupd" ------------------ 71| 0| return NULL; 72| 1|} fwupd_error_quark: 145| 3.20k|{ 146| 3.20k| static GQuark quark = 0; 147| 3.20k| if (!quark) { ------------------ | Branch (147:6): [True: 1, False: 3.20k] ------------------ 148| 1| quark = g_quark_from_static_string("FwupdError"); 149| 23| for (gint i = 0; i < FWUPD_ERROR_LAST; i++) { ------------------ | | 148| 23|#define FWUPD_ERROR_LAST 22 ------------------ | Branch (149:20): [True: 22, False: 1] ------------------ 150| 22| g_dbus_error_register_error(quark, i, fwupd_error_to_string(i)); 151| 22| } 152| 1| } 153| 3.20k| return quark; 154| 3.20k|} fu_byte_array_append_uint8: 77| 32.4k|{ 78| 32.4k| g_byte_array_append(array, &data, sizeof(data)); 79| 32.4k|} fu_byte_array_append_uint16: 93| 723|{ 94| 723| guint8 buf[2]; /* nocheck:zero-init */ 95| 723| fu_memwrite_uint16(buf, data, endian); 96| 723| g_byte_array_append(array, buf, sizeof(buf)); 97| 723|} fu_byte_array_append_uint32: 129| 274|{ 130| 274| guint8 buf[4]; /* nocheck:zero-init */ 131| 274| fu_memwrite_uint32(buf, data, endian); 132| 274| g_byte_array_append(array, buf, sizeof(buf)); 133| 274|} fu_byte_array_append_uint64: 147| 69|{ 148| 69| guint8 buf[8]; /* nocheck:zero-init */ 149| 69| fu_memwrite_uint64(buf, data, endian); 150| 69| g_byte_array_append(array, buf, sizeof(buf)); 151| 69|} fu_byte_array_append_bytes: 164| 313|{ 165| | g_byte_array_append(array, g_bytes_get_data(bytes, NULL), g_bytes_get_size(bytes)); 166| 313|} fu_cbor_parse: 299| 3.85k|{ 300| 3.85k| g_autoptr(FuCborItem) item = NULL; ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 301| 3.85k| FuCborParseHelper helper = { 302| 3.85k| .stream = stream, 303| 3.85k| .max_depth = max_depth, 304| 3.85k| .max_items = max_items, 305| 3.85k| .max_length = max_length, 306| 3.85k| }; 307| | 308| 3.85k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), NULL); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 26.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 309| 3.85k| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 310| | 311| 3.85k| if (offset != NULL) ------------------ | Branch (311:6): [True: 3.85k, False: 0] ------------------ 312| 3.85k| helper.offset = *offset; 313| 3.85k| item = fu_cbor_parse_item(&helper, 0, error); 314| 3.85k| if (item == NULL) { ------------------ | Branch (314:6): [True: 1.11k, False: 2.73k] ------------------ 315| 1.11k| g_prefix_error(error, "CBOR parsing failed @0x%x: ", (guint)helper.offset); 316| 1.11k| return NULL; 317| 1.11k| } 318| 2.73k| if (fu_cbor_item_get_kind(item) != FU_CBOR_ITEM_KIND_MAP && ------------------ | Branch (318:6): [True: 119, False: 2.62k] ------------------ 319| 119| fu_cbor_item_get_kind(item) != FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (319:6): [True: 103, False: 16] ------------------ 320| 103| g_set_error(error, 321| 103| FWUPD_ERROR, ------------------ | | 15| 103|#define FWUPD_ERROR fwupd_error_quark() ------------------ 322| 103| FWUPD_ERROR_INVALID_DATA, 323| 103| "CBOR data must start with array or map, got %s", 324| 103| fu_cbor_item_kind_to_string(fu_cbor_item_get_kind(item))); 325| 103| return NULL; 326| 103| } 327| | 328| | /* success */ 329| 2.63k| if (offset != NULL) ------------------ | Branch (329:6): [True: 2.63k, False: 0] ------------------ 330| 2.63k| *offset = helper.offset; 331| 2.63k| return g_steal_pointer(&item); ------------------ | | 222| 2.63k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 332| 2.73k|} fu-cbor-common.c:fu_cbor_parse_item: 109| 101k|{ 110| 101k| FuCborTag tag; 111| 101k| guint64 len = 0; 112| 101k| guint8 len_short; 113| 101k| guint8 value8 = 0; 114| | 115| 101k| if (!fu_input_stream_read_u8(helper->stream, helper->offset, &value8, error)) ------------------ | Branch (115:6): [True: 208, False: 101k] ------------------ 116| 208| return NULL; 117| | 118| 101k| if (!fu_size_checked_inc(&helper->offset, 1, error)) { ------------------ | Branch (118:6): [True: 0, False: 101k] ------------------ 119| 0| g_prefix_error_literal(error, "CBOR tag offset overflow: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 120| 0| return NULL; 121| 0| } 122| | 123| 101k| tag = (value8 & 0b11100000) >> 5; 124| 101k| g_debug("tag: %u [%s] @0x%x", tag, fu_cbor_tag_to_string(tag), (guint)helper->offset); ------------------ | | 351| 101k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 101k|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 352| 101k| G_LOG_LEVEL_DEBUG, \ | | 353| 101k| __VA_ARGS__) ------------------ 125| | 126| | /* process length */ 127| 101k| len_short = (guint)(value8 & 0b11111); 128| 101k| g_debug("len-short: %u", len_short); ------------------ | | 351| 101k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 101k|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 352| 101k| G_LOG_LEVEL_DEBUG, \ | | 353| 101k| __VA_ARGS__) ------------------ 129| 101k| if (len_short <= FU_CBOR_LEN_SHORT_MAX) { ------------------ | Branch (129:6): [True: 88.4k, False: 12.8k] ------------------ 130| 88.4k| len = len_short; 131| 88.4k| } else if (len_short == FU_CBOR_LEN_EXT8) { ------------------ | Branch (131:13): [True: 10.1k, False: 2.69k] ------------------ 132| 10.1k| if (!fu_input_stream_read_u8(helper->stream, helper->offset, &value8, error)) ------------------ | Branch (132:7): [True: 3, False: 10.1k] ------------------ 133| 3| return NULL; 134| 10.1k| len = value8; 135| | 136| 10.1k| if (!fu_size_checked_inc(&helper->offset, 1, error)) { ------------------ | Branch (136:7): [True: 0, False: 10.1k] ------------------ 137| 0| g_prefix_error_literal(error, "CBOR length8 offset overflow: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 138| 0| return NULL; 139| 0| } 140| 10.1k| } else if (len_short == FU_CBOR_LEN_EXT16) { ------------------ | Branch (140:13): [True: 928, False: 1.76k] ------------------ 141| 928| guint16 value16 = 0; 142| 928| if (!fu_input_stream_read_u16(helper->stream, ------------------ | Branch (142:7): [True: 9, False: 919] ------------------ 143| 928| helper->offset, 144| 928| &value16, 145| 928| G_BIG_ENDIAN, ------------------ | | 185| 928|#define G_BIG_ENDIAN 4321 ------------------ 146| 928| error)) 147| 9| return NULL; 148| 919| len = value16; 149| | 150| 919| if (!fu_size_checked_inc(&helper->offset, 2, error)) { ------------------ | Branch (150:7): [True: 0, False: 919] ------------------ 151| 0| g_prefix_error_literal(error, "CBOR length16 offset overflow: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 152| 0| return NULL; 153| 0| } 154| 1.76k| } else if (len_short == FU_CBOR_LEN_EXT32) { ------------------ | Branch (154:13): [True: 870, False: 892] ------------------ 155| 870| guint32 value32 = 0; 156| 870| if (!fu_input_stream_read_u32(helper->stream, ------------------ | Branch (156:7): [True: 10, False: 860] ------------------ 157| 870| helper->offset, 158| 870| &value32, 159| 870| G_BIG_ENDIAN, ------------------ | | 185| 870|#define G_BIG_ENDIAN 4321 ------------------ 160| 870| error)) 161| 10| return NULL; 162| 860| len = value32; 163| | 164| 860| if (!fu_size_checked_inc(&helper->offset, 4, error)) { ------------------ | Branch (164:7): [True: 0, False: 860] ------------------ 165| 0| g_prefix_error_literal(error, "CBOR length32 offset overflow: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 166| 0| return NULL; 167| 0| } 168| 892| } else if (len_short == FU_CBOR_LEN_EXT64) { ------------------ | Branch (168:13): [True: 878, False: 14] ------------------ 169| 878| guint64 value64 = 0; 170| 878| if (!fu_input_stream_read_u64(helper->stream, ------------------ | Branch (170:7): [True: 9, False: 869] ------------------ 171| 878| helper->offset, 172| 878| &value64, 173| 878| G_BIG_ENDIAN, ------------------ | | 185| 878|#define G_BIG_ENDIAN 4321 ------------------ 174| 878| error)) 175| 9| return NULL; 176| 869| if (value64 > G_MAXINT64) { ------------------ | | 100| 869|#define G_MAXINT64 G_GINT64_CONSTANT(0x7fffffffffffffff) | | ------------------ | | | | 64| 869|#define G_GINT64_CONSTANT(val) (val##L) | | ------------------ ------------------ | Branch (176:7): [True: 63, False: 806] ------------------ 177| 63| g_set_error_literal(error, 178| 63| FWUPD_ERROR, ------------------ | | 15| 63|#define FWUPD_ERROR fwupd_error_quark() ------------------ 179| 63| FWUPD_ERROR_INVALID_DATA, 180| 63| "lengths larger than s64:MAX are not supported"); 181| 63| return NULL; 182| 63| } 183| 806| len = value64; 184| | 185| 806| if (!fu_size_checked_inc(&helper->offset, 8, error)) { ------------------ | Branch (185:7): [True: 0, False: 806] ------------------ 186| 0| g_prefix_error_literal(error, "CBOR length64 offset overflow: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 187| 0| return NULL; 188| 0| } 189| 806| } else if (len_short == FU_CBOR_LEN_INDEFINITE) { ------------------ | Branch (189:13): [True: 6, False: 8] ------------------ 190| 6| g_set_error_literal(error, 191| 6| FWUPD_ERROR, ------------------ | | 15| 6|#define FWUPD_ERROR fwupd_error_quark() ------------------ 192| 6| FWUPD_ERROR_INVALID_DATA, 193| 6| "indefinite-length encoding is not supported"); 194| 6| return NULL; 195| 8| } else { 196| 8| g_set_error(error, 197| 8| FWUPD_ERROR, ------------------ | | 15| 8|#define FWUPD_ERROR fwupd_error_quark() ------------------ 198| 8| FWUPD_ERROR_INVALID_DATA, 199| 8| "short count %u is invalid", 200| 8| len_short); 201| 8| return NULL; 202| 8| } 203| 101k| if (len != len_short) ------------------ | Branch (203:6): [True: 9.27k, False: 91.8k] ------------------ 204| 9.27k| g_debug("len: %" G_GUINT64_FORMAT, len); ------------------ | | 351| 9.27k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 9.27k|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 352| 9.27k| G_LOG_LEVEL_DEBUG, \ | | 353| 9.27k| __VA_ARGS__) ------------------ 205| | 206| | /* process tags */ 207| 101k| if (tag == FU_CBOR_TAG_POS_INT) ------------------ | Branch (207:6): [True: 57.6k, False: 43.5k] ------------------ 208| 57.6k| return fu_cbor_item_new_integer(len); 209| 43.5k| if (tag == FU_CBOR_TAG_NEG_INT) ------------------ | Branch (209:6): [True: 14.4k, False: 29.0k] ------------------ 210| 14.4k| return fu_cbor_item_new_integer(-1 - (gint64)len); 211| 29.0k| if (tag == FU_CBOR_TAG_STRING) { ------------------ | Branch (211:6): [True: 2.87k, False: 26.2k] ------------------ 212| 2.87k| g_autofree gchar *str = NULL; ------------------ | | 1167| 2.87k|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 2.87k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 213| 2.87k| if (helper->max_length > 0 && len > helper->max_length) { ------------------ | Branch (213:7): [True: 2.87k, False: 0] | Branch (213:33): [True: 110, False: 2.76k] ------------------ 214| 110| g_set_error(error, 215| 110| FWUPD_ERROR, ------------------ | | 15| 110|#define FWUPD_ERROR fwupd_error_quark() ------------------ 216| 110| FWUPD_ERROR_INVALID_DATA, 217| 110| "string too long (%u of maximum %u)", 218| 110| (guint)len, 219| 110| helper->max_length); 220| 110| return NULL; 221| 110| } 222| 2.76k| str = fu_input_stream_read_string(helper->stream, helper->offset, len, error); 223| 2.76k| if (str == NULL) ------------------ | Branch (223:7): [True: 182, False: 2.58k] ------------------ 224| 182| return NULL; 225| 2.58k| if (!fu_size_checked_inc(&helper->offset, len, error)) ------------------ | Branch (225:7): [True: 0, False: 2.58k] ------------------ 226| 0| return NULL; 227| 2.58k| return fu_cbor_item_new_string_steal(g_steal_pointer(&str)); ------------------ | | 222| 2.58k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 228| 2.58k| } 229| 26.2k| if (tag == FU_CBOR_TAG_BYTES) { ------------------ | Branch (229:6): [True: 3.03k, False: 23.1k] ------------------ 230| 3.03k| g_autoptr(GBytes) blob = NULL; ------------------ | | 1162| 3.03k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.03k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 231| 3.03k| if (helper->max_length > 0 && len > helper->max_length) { ------------------ | Branch (231:7): [True: 3.03k, False: 0] | Branch (231:33): [True: 88, False: 2.94k] ------------------ 232| 88| g_set_error(error, 233| 88| FWUPD_ERROR, ------------------ | | 15| 88|#define FWUPD_ERROR fwupd_error_quark() ------------------ 234| 88| FWUPD_ERROR_INVALID_DATA, 235| 88| "bytes too long (%u of maximum %u)", 236| 88| (guint)len, 237| 88| helper->max_length); 238| 88| return NULL; 239| 88| } 240| 2.94k| blob = fu_input_stream_read_bytes(helper->stream, helper->offset, len, NULL, error); 241| 2.94k| if (blob == NULL) ------------------ | Branch (241:7): [True: 32, False: 2.91k] ------------------ 242| 32| return NULL; 243| 2.91k| if (!fu_size_checked_inc(&helper->offset, len, error)) ------------------ | Branch (243:7): [True: 0, False: 2.91k] ------------------ 244| 0| return NULL; 245| 2.91k| return fu_cbor_item_new_bytes(blob); 246| 2.91k| } 247| 23.1k| if (tag == FU_CBOR_TAG_SPECIAL) { ------------------ | Branch (247:6): [True: 2.21k, False: 20.9k] ------------------ 248| 2.21k| if (len == FU_CBOR_SPECIAL_VALUE_TRUE) ------------------ | Branch (248:7): [True: 1.16k, False: 1.05k] ------------------ 249| 1.16k| return fu_cbor_item_new_boolean(TRUE); ------------------ | | 818| 1.16k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1.16k|#define FALSE (0) | | ------------------ ------------------ 250| 1.05k| if (len == FU_CBOR_SPECIAL_VALUE_FALSE) ------------------ | Branch (250:7): [True: 685, False: 372] ------------------ 251| 685| return fu_cbor_item_new_boolean(FALSE); ------------------ | | 814| 685|#define FALSE (0) ------------------ 252| 372| if (len == FU_CBOR_SPECIAL_VALUE_NULL) ------------------ | Branch (252:7): [True: 218, False: 154] ------------------ 253| 218| return fu_cbor_item_new_string(NULL); 254| 154| g_set_error(error, 255| 154| FWUPD_ERROR, ------------------ | | 15| 154|#define FWUPD_ERROR fwupd_error_quark() ------------------ 256| 154| FWUPD_ERROR_INVALID_DATA, 257| 154| "special value %u [%s] is not handled", 258| 154| (guint)len, 259| 154| fu_cbor_special_value_to_string(len)); 260| 154| return NULL; 261| 372| } 262| 20.9k| if (tag == FU_CBOR_TAG_MAP) ------------------ | Branch (262:6): [True: 16.9k, False: 4.05k] ------------------ 263| 16.9k| return fu_cbor_parse_map(helper, len, current_depth + 1, error); 264| 4.05k| if (tag == FU_CBOR_TAG_ARRAY) ------------------ | Branch (264:6): [True: 4.04k, False: 6] ------------------ 265| 4.04k| return fu_cbor_parse_array(helper, len, current_depth + 1, error); 266| | 267| | /* unknown */ 268| 6| g_set_error(error, 269| 6| FWUPD_ERROR, ------------------ | | 15| 6|#define FWUPD_ERROR fwupd_error_quark() ------------------ 270| 6| FWUPD_ERROR_INVALID_DATA, 271| 6| "tag %u [%s] is not handled", 272| 6| tag, 273| 6| fu_cbor_tag_to_string(tag)); 274| | return NULL; 275| 4.05k|} fu-cbor-common.c:fu_cbor_parse_map: 29| 16.9k|{ 30| 16.9k| g_autoptr(FuCborItem) item = fu_cbor_item_new_map(); ------------------ | | 1162| 16.9k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 16.9k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 31| | 32| | /* sanity check */ 33| 16.9k| if (helper->max_depth > 0 && current_depth > helper->max_depth) { ------------------ | Branch (33:6): [True: 16.9k, False: 0] | Branch (33:31): [True: 1, False: 16.9k] ------------------ 34| 1| g_set_error(error, 35| 1| FWUPD_ERROR, ------------------ | | 15| 1|#define FWUPD_ERROR fwupd_error_quark() ------------------ 36| 1| FWUPD_ERROR_INVALID_DATA, 37| 1| "reached max depth of %u", 38| 1| current_depth); 39| 1| return NULL; 40| 1| } 41| 16.9k| if (helper->max_items > 0 && len > helper->max_items) { ------------------ | Branch (41:6): [True: 16.9k, False: 0] | Branch (41:31): [True: 113, False: 16.8k] ------------------ 42| 113| g_set_error(error, 43| 113| FWUPD_ERROR, ------------------ | | 15| 113|#define FWUPD_ERROR fwupd_error_quark() ------------------ 44| 113| FWUPD_ERROR_INVALID_DATA, 45| 113| "too many items (%u of maximum %u)", 46| 113| (guint)len, 47| 113| helper->max_items); 48| 113| return NULL; 49| 113| } 50| | 51| 16.8k| g_debug("map has %u items", (guint)len); ------------------ | | 351| 16.8k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 16.8k|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 352| 16.8k| G_LOG_LEVEL_DEBUG, \ | | 353| 16.8k| __VA_ARGS__) ------------------ 52| 57.4k| for (guint64 i = 0; i < len; i++) { ------------------ | Branch (52:22): [True: 41.0k, False: 16.4k] ------------------ 53| 41.0k| g_autoptr(FuCborItem) item_key = NULL; ------------------ | | 1162| 41.0k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 41.0k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 54| 41.0k| g_autoptr(FuCborItem) item_val = NULL; ------------------ | | 1162| 41.0k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 41.0k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 55| 41.0k| item_key = fu_cbor_parse_item(helper, current_depth, error); 56| 41.0k| if (item_key == NULL) ------------------ | Branch (56:7): [True: 228, False: 40.8k] ------------------ 57| 228| return NULL; 58| 40.8k| item_val = fu_cbor_parse_item(helper, current_depth, error); 59| 40.8k| if (item_val == NULL) ------------------ | Branch (59:7): [True: 173, False: 40.6k] ------------------ 60| 173| return NULL; 61| 40.6k| if (!fu_cbor_item_map_append(item, item_key, item_val, error)) ------------------ | Branch (61:7): [True: 0, False: 40.6k] ------------------ 62| 0| return NULL; 63| 40.6k| } 64| | 65| | /* success */ 66| 16.4k| return g_steal_pointer(&item); ------------------ | | 222| 16.4k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 67| 16.8k|} fu-cbor-common.c:fu_cbor_parse_array: 71| 4.04k|{ 72| 4.04k| g_autoptr(FuCborItem) item = fu_cbor_item_new_array(); ------------------ | | 1162| 4.04k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 4.04k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 73| | 74| | /* sanity check */ 75| 4.04k| if (helper->max_depth > 0 && current_depth > helper->max_depth) { ------------------ | Branch (75:6): [True: 4.04k, False: 0] | Branch (75:31): [True: 2, False: 4.04k] ------------------ 76| 2| g_set_error(error, 77| 2| FWUPD_ERROR, ------------------ | | 15| 2|#define FWUPD_ERROR fwupd_error_quark() ------------------ 78| 2| FWUPD_ERROR_INVALID_DATA, 79| 2| "reached max depth of %u", 80| 2| current_depth); 81| 2| return NULL; 82| 2| } 83| 4.04k| if (helper->max_items > 0 && len > helper->max_items) { ------------------ | Branch (83:6): [True: 4.04k, False: 0] | Branch (83:31): [True: 108, False: 3.93k] ------------------ 84| 108| g_set_error(error, 85| 108| FWUPD_ERROR, ------------------ | | 15| 108|#define FWUPD_ERROR fwupd_error_quark() ------------------ 86| 108| FWUPD_ERROR_INVALID_DATA, 87| 108| "too many items (%u of maximum %u)", 88| 108| (guint)len, 89| 108| helper->max_items); 90| 108| return NULL; 91| 108| } 92| | 93| 3.93k| g_debug("array has %u items", (guint)len); ------------------ | | 351| 3.93k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 3.93k|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 352| 3.93k| G_LOG_LEVEL_DEBUG, \ | | 353| 3.93k| __VA_ARGS__) ------------------ 94| 19.4k| for (guint64 i = 0; i < len; i++) { ------------------ | Branch (94:22): [True: 15.7k, False: 3.73k] ------------------ 95| 15.7k| g_autoptr(FuCborItem) item_tmp = NULL; ------------------ | | 1162| 15.7k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 15.7k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 96| 15.7k| item_tmp = fu_cbor_parse_item(helper, current_depth, error); 97| 15.7k| if (item_tmp == NULL) ------------------ | Branch (97:7): [True: 204, False: 15.5k] ------------------ 98| 204| return NULL; 99| 15.5k| if (!fu_cbor_item_array_append(item, item_tmp, error)) ------------------ | Branch (99:7): [True: 0, False: 15.5k] ------------------ 100| 0| return NULL; 101| 15.5k| } 102| | 103| | /* success */ 104| 3.73k| return g_steal_pointer(&item); ------------------ | | 222| 3.73k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 105| 3.93k|} fu_cbor_item_get_kind: 46| 22.5k|{ 47| 22.5k| g_return_val_if_fail(self != NULL, 0); ------------------ | | 643| 22.5k| G_STMT_START { \ | | ------------------ | | | | 874| 22.5k|#define G_STMT_START do | | ------------------ | | 644| 22.5k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 22.5k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 22.5k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 22.5k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 22.5k| int _g_boolean_var_; \ | | | | | | 1018| 22.5k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 22.5k, False: 0] | | | | | | ------------------ | | | | | | 1019| 22.5k| _g_boolean_var_ = 1; \ | | | | | | 1020| 22.5k| else \ | | | | | | 1021| 22.5k| _g_boolean_var_ = 0; \ | | | | | | 1022| 22.5k| _g_boolean_var_; \ | | | | | | 1023| 22.5k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 22.5k, False: 0] | | | | ------------------ | | ------------------ | | 645| 22.5k| { } \ | | 646| 22.5k| else \ | | 647| 22.5k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 22.5k| } G_STMT_END | | ------------------ | | | | 882| 22.5k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 22.5k] | | | | ------------------ | | ------------------ ------------------ 48| 22.5k| return self->kind; 49| 22.5k|} fu_cbor_item_get_integer: 65| 34.9k|{ 66| 34.9k| g_return_val_if_fail(self != NULL, FALSE); ------------------ | | 643| 34.9k| G_STMT_START { \ | | ------------------ | | | | 874| 34.9k|#define G_STMT_START do | | ------------------ | | 644| 34.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 34.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 34.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 34.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 34.9k| int _g_boolean_var_; \ | | | | | | 1018| 34.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 34.9k, False: 0] | | | | | | ------------------ | | | | | | 1019| 34.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 34.9k| else \ | | | | | | 1021| 34.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 34.9k| _g_boolean_var_; \ | | | | | | 1023| 34.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 34.9k, False: 0] | | | | ------------------ | | ------------------ | | 645| 34.9k| { } \ | | 646| 34.9k| else \ | | 647| 34.9k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 34.9k| } G_STMT_END | | ------------------ | | | | 882| 34.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 34.9k] | | | | ------------------ | | ------------------ ------------------ 67| 34.9k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 34.9k| G_STMT_START { \ | | ------------------ | | | | 874| 34.9k|#define G_STMT_START do | | ------------------ | | 644| 34.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 34.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 34.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 34.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 34.9k| int _g_boolean_var_; \ | | | | | | 1018| 69.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 34.9k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 34.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 34.9k| else \ | | | | | | 1021| 34.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 34.9k| _g_boolean_var_; \ | | | | | | 1023| 34.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 34.9k, False: 0] | | | | ------------------ | | ------------------ | | 645| 34.9k| { } \ | | 646| 34.9k| else \ | | 647| 34.9k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 34.9k| } G_STMT_END | | ------------------ | | | | 882| 34.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 34.9k] | | | | ------------------ | | ------------------ ------------------ 68| | 69| 34.9k| if (self->kind != FU_CBOR_ITEM_KIND_INTEGER) { ------------------ | Branch (69:6): [True: 63, False: 34.9k] ------------------ 70| 63| g_set_error(error, 71| 63| FWUPD_ERROR, ------------------ | | 15| 63|#define FWUPD_ERROR fwupd_error_quark() ------------------ 72| 63| FWUPD_ERROR_NOT_SUPPORTED, 73| 63| "item kind invalid, got %s", 74| 63| fu_cbor_item_kind_to_string(self->kind)); 75| 63| return FALSE; ------------------ | | 814| 63|#define FALSE (0) ------------------ 76| 63| } 77| 34.9k| if (value != NULL) ------------------ | Branch (77:6): [True: 34.9k, False: 0] ------------------ 78| 34.9k| *value = FU_CBOR_ITEM_TO_INT64(self); ------------------ | | 31| 34.9k|#define FU_CBOR_ITEM_TO_INT64(self) (*((gint64 *)self->value)) ------------------ 79| 34.9k| return TRUE; ------------------ | | 818| 34.9k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 34.9k|#define FALSE (0) | | ------------------ ------------------ 80| 34.9k|} fu_cbor_item_get_string: 126| 1.09k|{ 127| 1.09k| const gchar *str; 128| | 129| 1.09k| g_return_val_if_fail(self != NULL, NULL); ------------------ | | 643| 1.09k| G_STMT_START { \ | | ------------------ | | | | 874| 1.09k|#define G_STMT_START do | | ------------------ | | 644| 1.09k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1.09k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1.09k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1.09k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1.09k| int _g_boolean_var_; \ | | | | | | 1018| 1.09k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1.09k, False: 0] | | | | | | ------------------ | | | | | | 1019| 1.09k| _g_boolean_var_ = 1; \ | | | | | | 1020| 1.09k| else \ | | | | | | 1021| 1.09k| _g_boolean_var_ = 0; \ | | | | | | 1022| 1.09k| _g_boolean_var_; \ | | | | | | 1023| 1.09k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1.09k, False: 0] | | | | ------------------ | | ------------------ | | 645| 1.09k| { } \ | | 646| 1.09k| else \ | | 647| 1.09k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1.09k| } G_STMT_END | | ------------------ | | | | 882| 1.09k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1.09k] | | | | ------------------ | | ------------------ ------------------ 130| 1.09k| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 1.09k| G_STMT_START { \ | | ------------------ | | | | 874| 1.09k|#define G_STMT_START do | | ------------------ | | 644| 1.09k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1.09k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1.09k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1.09k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1.09k| int _g_boolean_var_; \ | | | | | | 1018| 2.18k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1.09k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 1.09k| _g_boolean_var_ = 1; \ | | | | | | 1020| 1.09k| else \ | | | | | | 1021| 1.09k| _g_boolean_var_ = 0; \ | | | | | | 1022| 1.09k| _g_boolean_var_; \ | | | | | | 1023| 1.09k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1.09k, False: 0] | | | | ------------------ | | ------------------ | | 645| 1.09k| { } \ | | 646| 1.09k| else \ | | 647| 1.09k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1.09k| } G_STMT_END | | ------------------ | | | | 882| 1.09k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1.09k] | | | | ------------------ | | ------------------ ------------------ 131| | 132| 1.09k| if (self->kind != FU_CBOR_ITEM_KIND_STRING) { ------------------ | Branch (132:6): [True: 0, False: 1.09k] ------------------ 133| 0| g_set_error(error, 134| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 135| 0| FWUPD_ERROR_NOT_SUPPORTED, 136| 0| "item kind invalid, got %s", 137| 0| fu_cbor_item_kind_to_string(self->kind)); 138| 0| return NULL; 139| 0| } 140| 1.09k| str = FU_CBOR_ITEM_TO_STRING(self); ------------------ | | 30| 1.09k|#define FU_CBOR_ITEM_TO_STRING(self) ((gchar *)self->value) ------------------ 141| 1.09k| if (str == NULL) { ------------------ | Branch (141:6): [True: 1, False: 1.09k] ------------------ 142| 1| g_set_error_literal(error, FWUPD_ERROR, FWUPD_ERROR_NOT_FOUND, "empty string"); ------------------ | | 15| 1|#define FWUPD_ERROR fwupd_error_quark() ------------------ 143| 1| return NULL; 144| 1| } 145| 1.09k| return g_strdup(str); 146| 1.09k|} fu_cbor_item_get_bytes: 161| 793|{ 162| 793| GBytes *blob; 163| | 164| 793| g_return_val_if_fail(self != NULL, NULL); ------------------ | | 643| 793| G_STMT_START { \ | | ------------------ | | | | 874| 793|#define G_STMT_START do | | ------------------ | | 644| 793| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 793|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 793| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 793|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 793| int _g_boolean_var_; \ | | | | | | 1018| 793| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 793, False: 0] | | | | | | ------------------ | | | | | | 1019| 793| _g_boolean_var_ = 1; \ | | | | | | 1020| 793| else \ | | | | | | 1021| 793| _g_boolean_var_ = 0; \ | | | | | | 1022| 793| _g_boolean_var_; \ | | | | | | 1023| 793|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 793, False: 0] | | | | ------------------ | | ------------------ | | 645| 793| { } \ | | 646| 793| else \ | | 647| 793| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 793| } G_STMT_END | | ------------------ | | | | 882| 793|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 793] | | | | ------------------ | | ------------------ ------------------ 165| 793| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 793| G_STMT_START { \ | | ------------------ | | | | 874| 793|#define G_STMT_START do | | ------------------ | | 644| 793| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 793|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 793| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 793|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 793| int _g_boolean_var_; \ | | | | | | 1018| 1.58k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 793, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 793| _g_boolean_var_ = 1; \ | | | | | | 1020| 793| else \ | | | | | | 1021| 793| _g_boolean_var_ = 0; \ | | | | | | 1022| 793| _g_boolean_var_; \ | | | | | | 1023| 793|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 793, False: 0] | | | | ------------------ | | ------------------ | | 645| 793| { } \ | | 646| 793| else \ | | 647| 793| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 793| } G_STMT_END | | ------------------ | | | | 882| 793|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 793] | | | | ------------------ | | ------------------ ------------------ 166| | 167| 793| if (self->kind != FU_CBOR_ITEM_KIND_BYTES) { ------------------ | Branch (167:6): [True: 4, False: 789] ------------------ 168| 4| g_set_error(error, 169| 4| FWUPD_ERROR, ------------------ | | 15| 4|#define FWUPD_ERROR fwupd_error_quark() ------------------ 170| 4| FWUPD_ERROR_NOT_SUPPORTED, 171| 4| "item kind invalid, got %s", 172| 4| fu_cbor_item_kind_to_string(self->kind)); 173| 4| return NULL; 174| 4| } 175| 789| blob = FU_CBOR_ITEM_TO_BYTES(self); ------------------ | | 29| 789|#define FU_CBOR_ITEM_TO_BYTES(self) ((GBytes *)self->value) ------------------ 176| 789| if (blob == NULL) { ------------------ | Branch (176:6): [True: 0, False: 789] ------------------ 177| 0| g_set_error_literal(error, 178| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 179| 0| FWUPD_ERROR_NOT_SUPPORTED, 180| 0| "empty byte array"); 181| 0| return NULL; 182| 0| } 183| 789| return g_bytes_ref(blob); 184| 789|} fu_cbor_item_array_length: 198| 9.74k|{ 199| 9.74k| g_return_val_if_fail(self != NULL, G_MAXUINT); ------------------ | | 643| 9.74k| G_STMT_START { \ | | ------------------ | | | | 874| 9.74k|#define G_STMT_START do | | ------------------ | | 644| 9.74k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 9.74k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 9.74k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 9.74k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 9.74k| int _g_boolean_var_; \ | | | | | | 1018| 9.74k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 9.74k, False: 0] | | | | | | ------------------ | | | | | | 1019| 9.74k| _g_boolean_var_ = 1; \ | | | | | | 1020| 9.74k| else \ | | | | | | 1021| 9.74k| _g_boolean_var_ = 0; \ | | | | | | 1022| 9.74k| _g_boolean_var_; \ | | | | | | 1023| 9.74k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 9.74k, False: 0] | | | | ------------------ | | ------------------ | | 645| 9.74k| { } \ | | 646| 9.74k| else \ | | 647| 9.74k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 9.74k| } G_STMT_END | | ------------------ | | | | 882| 9.74k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 9.74k] | | | | ------------------ | | ------------------ ------------------ 200| 9.74k| g_return_val_if_fail(self->kind == FU_CBOR_ITEM_KIND_ARRAY, G_MAXUINT); ------------------ | | 643| 9.74k| G_STMT_START { \ | | ------------------ | | | | 874| 9.74k|#define G_STMT_START do | | ------------------ | | 644| 9.74k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 9.74k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 9.74k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 9.74k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 9.74k| int _g_boolean_var_; \ | | | | | | 1018| 9.74k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 9.74k, False: 0] | | | | | | ------------------ | | | | | | 1019| 9.74k| _g_boolean_var_ = 1; \ | | | | | | 1020| 9.74k| else \ | | | | | | 1021| 9.74k| _g_boolean_var_ = 0; \ | | | | | | 1022| 9.74k| _g_boolean_var_; \ | | | | | | 1023| 9.74k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 9.74k, False: 0] | | | | ------------------ | | ------------------ | | 645| 9.74k| { } \ | | 646| 9.74k| else \ | | 647| 9.74k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 9.74k| } G_STMT_END | | ------------------ | | | | 882| 9.74k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 9.74k] | | | | ------------------ | | ------------------ ------------------ 201| 9.74k| return FU_CBOR_ITEM_TO_ARRAY(self)->len; ------------------ | | 28| 9.74k|#define FU_CBOR_ITEM_TO_ARRAY(self) ((GPtrArray *)self->value) ------------------ 202| 9.74k|} fu_cbor_item_map_length: 216| 45.1k|{ 217| 45.1k| g_return_val_if_fail(self != NULL, G_MAXUINT); ------------------ | | 643| 45.1k| G_STMT_START { \ | | ------------------ | | | | 874| 45.1k|#define G_STMT_START do | | ------------------ | | 644| 45.1k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 45.1k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 45.1k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 45.1k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 45.1k| int _g_boolean_var_; \ | | | | | | 1018| 45.1k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 45.1k, False: 0] | | | | | | ------------------ | | | | | | 1019| 45.1k| _g_boolean_var_ = 1; \ | | | | | | 1020| 45.1k| else \ | | | | | | 1021| 45.1k| _g_boolean_var_ = 0; \ | | | | | | 1022| 45.1k| _g_boolean_var_; \ | | | | | | 1023| 45.1k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 45.1k, False: 0] | | | | ------------------ | | ------------------ | | 645| 45.1k| { } \ | | 646| 45.1k| else \ | | 647| 45.1k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 45.1k| } G_STMT_END | | ------------------ | | | | 882| 45.1k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 45.1k] | | | | ------------------ | | ------------------ ------------------ 218| 45.1k| g_return_val_if_fail(self->kind == FU_CBOR_ITEM_KIND_MAP, G_MAXUINT); ------------------ | | 643| 45.1k| G_STMT_START { \ | | ------------------ | | | | 874| 45.1k|#define G_STMT_START do | | ------------------ | | 644| 45.1k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 45.1k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 45.1k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 45.1k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 45.1k| int _g_boolean_var_; \ | | | | | | 1018| 45.1k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 45.1k, False: 0] | | | | | | ------------------ | | | | | | 1019| 45.1k| _g_boolean_var_ = 1; \ | | | | | | 1020| 45.1k| else \ | | | | | | 1021| 45.1k| _g_boolean_var_ = 0; \ | | | | | | 1022| 45.1k| _g_boolean_var_; \ | | | | | | 1023| 45.1k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 45.1k, False: 0] | | | | ------------------ | | ------------------ | | 645| 45.1k| { } \ | | 646| 45.1k| else \ | | 647| 45.1k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 45.1k| } G_STMT_END | | ------------------ | | | | 882| 45.1k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 45.1k] | | | | ------------------ | | ------------------ ------------------ 219| 45.1k| return FU_CBOR_ITEM_TO_ARRAY(self)->len; ------------------ | | 28| 45.1k|#define FU_CBOR_ITEM_TO_ARRAY(self) ((GPtrArray *)self->value) ------------------ 220| 45.1k|} fu_cbor_item_array_index: 235| 9.02k|{ 236| 9.02k| g_return_val_if_fail(self != NULL, NULL); ------------------ | | 643| 9.02k| G_STMT_START { \ | | ------------------ | | | | 874| 9.02k|#define G_STMT_START do | | ------------------ | | 644| 9.02k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 9.02k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 9.02k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 9.02k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 9.02k| int _g_boolean_var_; \ | | | | | | 1018| 9.02k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 9.02k, False: 0] | | | | | | ------------------ | | | | | | 1019| 9.02k| _g_boolean_var_ = 1; \ | | | | | | 1020| 9.02k| else \ | | | | | | 1021| 9.02k| _g_boolean_var_ = 0; \ | | | | | | 1022| 9.02k| _g_boolean_var_; \ | | | | | | 1023| 9.02k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 9.02k, False: 0] | | | | ------------------ | | ------------------ | | 645| 9.02k| { } \ | | 646| 9.02k| else \ | | 647| 9.02k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 9.02k| } G_STMT_END | | ------------------ | | | | 882| 9.02k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 9.02k] | | | | ------------------ | | ------------------ ------------------ 237| 9.02k| g_return_val_if_fail(self->kind == FU_CBOR_ITEM_KIND_ARRAY, NULL); ------------------ | | 643| 9.02k| G_STMT_START { \ | | ------------------ | | | | 874| 9.02k|#define G_STMT_START do | | ------------------ | | 644| 9.02k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 9.02k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 9.02k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 9.02k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 9.02k| int _g_boolean_var_; \ | | | | | | 1018| 9.02k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 9.02k, False: 0] | | | | | | ------------------ | | | | | | 1019| 9.02k| _g_boolean_var_ = 1; \ | | | | | | 1020| 9.02k| else \ | | | | | | 1021| 9.02k| _g_boolean_var_ = 0; \ | | | | | | 1022| 9.02k| _g_boolean_var_; \ | | | | | | 1023| 9.02k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 9.02k, False: 0] | | | | ------------------ | | ------------------ | | 645| 9.02k| { } \ | | 646| 9.02k| else \ | | 647| 9.02k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 9.02k| } G_STMT_END | | ------------------ | | | | 882| 9.02k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 9.02k] | | | | ------------------ | | ------------------ ------------------ 238| 9.02k| g_return_val_if_fail(idx < FU_CBOR_ITEM_TO_ARRAY(self)->len, NULL); ------------------ | | 643| 9.02k| G_STMT_START { \ | | ------------------ | | | | 874| 9.02k|#define G_STMT_START do | | ------------------ | | 644| 9.02k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 9.02k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 9.02k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 9.02k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 9.02k| int _g_boolean_var_; \ | | | | | | 1018| 9.02k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 9.02k, False: 0] | | | | | | ------------------ | | | | | | 1019| 9.02k| _g_boolean_var_ = 1; \ | | | | | | 1020| 9.02k| else \ | | | | | | 1021| 9.02k| _g_boolean_var_ = 0; \ | | | | | | 1022| 9.02k| _g_boolean_var_; \ | | | | | | 1023| 9.02k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 9.02k, False: 0] | | | | ------------------ | | ------------------ | | 645| 9.02k| { } \ | | 646| 9.02k| else \ | | 647| 9.02k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 9.02k| } G_STMT_END | | ------------------ | | | | 882| 9.02k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 9.02k] | | | | ------------------ | | ------------------ ------------------ 239| 9.02k| return g_ptr_array_index(FU_CBOR_ITEM_TO_ARRAY(self), idx); ------------------ | | 138| 9.02k|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 240| 9.02k|} fu_cbor_item_map_index: 255| 32.9k|{ 256| 32.9k| FuCborPair *pair; 257| 32.9k| g_return_if_fail(self != NULL); ------------------ | | 630| 32.9k| G_STMT_START { \ | | ------------------ | | | | 874| 32.9k|#define G_STMT_START do | | ------------------ | | 631| 32.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 32.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 32.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 32.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 32.9k| int _g_boolean_var_; \ | | | | | | 1018| 32.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 32.9k, False: 0] | | | | | | ------------------ | | | | | | 1019| 32.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 32.9k| else \ | | | | | | 1021| 32.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 32.9k| _g_boolean_var_; \ | | | | | | 1023| 32.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 32.9k, False: 0] | | | | ------------------ | | ------------------ | | 632| 32.9k| { } \ | | 633| 32.9k| else \ | | 634| 32.9k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 32.9k| } G_STMT_END | | ------------------ | | | | 882| 32.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 32.9k] | | | | ------------------ | | ------------------ ------------------ 258| 32.9k| g_return_if_fail(self->kind == FU_CBOR_ITEM_KIND_MAP); ------------------ | | 630| 32.9k| G_STMT_START { \ | | ------------------ | | | | 874| 32.9k|#define G_STMT_START do | | ------------------ | | 631| 32.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 32.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 32.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 32.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 32.9k| int _g_boolean_var_; \ | | | | | | 1018| 32.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 32.9k, False: 0] | | | | | | ------------------ | | | | | | 1019| 32.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 32.9k| else \ | | | | | | 1021| 32.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 32.9k| _g_boolean_var_; \ | | | | | | 1023| 32.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 32.9k, False: 0] | | | | ------------------ | | ------------------ | | 632| 32.9k| { } \ | | 633| 32.9k| else \ | | 634| 32.9k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 32.9k| } G_STMT_END | | ------------------ | | | | 882| 32.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 32.9k] | | | | ------------------ | | ------------------ ------------------ 259| 32.9k| g_return_if_fail(idx < FU_CBOR_ITEM_TO_ARRAY(self)->len); ------------------ | | 630| 32.9k| G_STMT_START { \ | | ------------------ | | | | 874| 32.9k|#define G_STMT_START do | | ------------------ | | 631| 32.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 32.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 32.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 32.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 32.9k| int _g_boolean_var_; \ | | | | | | 1018| 32.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 32.9k, False: 0] | | | | | | ------------------ | | | | | | 1019| 32.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 32.9k| else \ | | | | | | 1021| 32.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 32.9k| _g_boolean_var_; \ | | | | | | 1023| 32.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 32.9k, False: 0] | | | | ------------------ | | ------------------ | | 632| 32.9k| { } \ | | 633| 32.9k| else \ | | 634| 32.9k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 32.9k| } G_STMT_END | | ------------------ | | | | 882| 32.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 32.9k] | | | | ------------------ | | ------------------ ------------------ 260| 32.9k| pair = g_ptr_array_index(FU_CBOR_ITEM_TO_ARRAY(self), idx); ------------------ | | 138| 32.9k|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 261| 32.9k| if (item_key != NULL) ------------------ | Branch (261:6): [True: 32.9k, False: 0] ------------------ 262| 32.9k| *item_key = pair->key; 263| 32.9k| if (item_value != NULL) ------------------ | Branch (263:6): [True: 32.9k, False: 0] ------------------ 264| 32.9k| *item_value = pair->val; 265| 32.9k|} fu_cbor_item_write: 380| 761|{ 381| 761| g_autoptr(GByteArray) buf = g_byte_array_new(); ------------------ | | 1162| 761|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 761|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 382| | 383| 761| g_return_val_if_fail(self != NULL, NULL); ------------------ | | 643| 761| G_STMT_START { \ | | ------------------ | | | | 874| 761|#define G_STMT_START do | | ------------------ | | 644| 761| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 761|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 761| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 761|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 761| int _g_boolean_var_; \ | | | | | | 1018| 761| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 761, False: 0] | | | | | | ------------------ | | | | | | 1019| 761| _g_boolean_var_ = 1; \ | | | | | | 1020| 761| else \ | | | | | | 1021| 761| _g_boolean_var_ = 0; \ | | | | | | 1022| 761| _g_boolean_var_; \ | | | | | | 1023| 761|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 761, False: 0] | | | | ------------------ | | ------------------ | | 645| 761| { } \ | | 646| 761| else \ | | 647| 761| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 761| } G_STMT_END | | ------------------ | | | | 882| 761|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 761] | | | | ------------------ | | ------------------ ------------------ 384| 761| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 761| G_STMT_START { \ | | ------------------ | | | | 874| 761|#define G_STMT_START do | | ------------------ | | 644| 761| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 761|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 761| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 761|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 761| int _g_boolean_var_; \ | | | | | | 1018| 1.52k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 761, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 761| _g_boolean_var_ = 1; \ | | | | | | 1020| 761| else \ | | | | | | 1021| 761| _g_boolean_var_ = 0; \ | | | | | | 1022| 761| _g_boolean_var_; \ | | | | | | 1023| 761|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 761, False: 0] | | | | ------------------ | | ------------------ | | 645| 761| { } \ | | 646| 761| else \ | | 647| 761| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 761| } G_STMT_END | | ------------------ | | | | 882| 761|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 761] | | | | ------------------ | | ------------------ ------------------ 385| | 386| | /* sanity check */ 387| 761| if (self->kind != FU_CBOR_ITEM_KIND_MAP && self->kind != FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (387:6): [True: 0, False: 761] | Branch (387:45): [True: 0, False: 0] ------------------ 388| 0| g_set_error(error, 389| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 390| 0| FWUPD_ERROR_NOT_SUPPORTED, 391| 0| "can only write map or array, not %s", 392| 0| fu_cbor_item_kind_to_string(self->kind)); 393| 0| return NULL; 394| 0| } 395| 761| if (!fu_cbor_item_append(self, buf, error)) ------------------ | Branch (395:6): [True: 0, False: 761] ------------------ 396| 0| return NULL; 397| | 398| | /* success */ 399| 761| return g_steal_pointer(&buf); ------------------ | | 222| 761|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 400| 761|} fu_cbor_item_ref: 414| 123k|{ 415| 123k| g_return_val_if_fail(self != NULL, NULL); ------------------ | | 643| 123k| G_STMT_START { \ | | ------------------ | | | | 874| 123k|#define G_STMT_START do | | ------------------ | | 644| 123k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 123k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 123k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 123k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 123k| int _g_boolean_var_; \ | | | | | | 1018| 123k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 123k, False: 0] | | | | | | ------------------ | | | | | | 1019| 123k| _g_boolean_var_ = 1; \ | | | | | | 1020| 123k| else \ | | | | | | 1021| 123k| _g_boolean_var_ = 0; \ | | | | | | 1022| 123k| _g_boolean_var_; \ | | | | | | 1023| 123k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 123k, False: 0] | | | | ------------------ | | ------------------ | | 645| 123k| { } \ | | 646| 123k| else \ | | 647| 123k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 123k| } G_STMT_END | | ------------------ | | | | 882| 123k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 123k] | | | | ------------------ | | ------------------ ------------------ 416| 123k| g_ref_count_inc(&self->refcount); 417| 123k| return self; 418| 123k|} fu_cbor_item_unref: 432| 250k|{ 433| 250k| g_return_val_if_fail(self != NULL, NULL); ------------------ | | 643| 250k| G_STMT_START { \ | | ------------------ | | | | 874| 250k|#define G_STMT_START do | | ------------------ | | 644| 250k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 250k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 250k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 250k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 250k| int _g_boolean_var_; \ | | | | | | 1018| 250k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 250k, False: 0] | | | | | | ------------------ | | | | | | 1019| 250k| _g_boolean_var_ = 1; \ | | | | | | 1020| 250k| else \ | | | | | | 1021| 250k| _g_boolean_var_ = 0; \ | | | | | | 1022| 250k| _g_boolean_var_; \ | | | | | | 1023| 250k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 250k, False: 0] | | | | ------------------ | | ------------------ | | 645| 250k| { } \ | | 646| 250k| else \ | | 647| 250k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 250k| } G_STMT_END | | ------------------ | | | | 882| 250k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 250k] | | | | ------------------ | | ------------------ ------------------ 434| 250k| if (!g_ref_count_dec(&self->refcount)) ------------------ | Branch (434:6): [True: 123k, False: 127k] ------------------ 435| 123k| return self; 436| 127k| if (self->value_destroy != NULL) ------------------ | Branch (436:6): [True: 124k, False: 2.60k] ------------------ 437| 124k| self->value_destroy(self->value); 438| 127k| g_free(self); 439| | return NULL; 440| 250k|} fu_cbor_item_new_string: 454| 2.22k|{ 455| | FuCborItem *self = g_new0(FuCborItem, 1); ------------------ | | 307| 2.22k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2.22k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2.22k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2.22k| gsize __n = (gsize) (n_structs); \ | | | | 237| 2.22k| gsize __s = sizeof (struct_type); \ | | | | 238| 2.22k| gpointer __p; \ | | | | 239| 2.22k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2.22k] | | | | ------------------ | | | | 240| 2.22k| __p = g_##func (__n); \ | | | | 241| 2.22k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 2.22k, False: 0] | | | | ------------------ | | | | 242| 2.22k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 2.22k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 2.22k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 2.22k] | | | | | Branch (242:26): [True: 2.22k, False: 0] | | | | ------------------ | | | | 243| 2.22k| __p = g_##func (__n * __s); \ | | | | 244| 2.22k| else \ | | | | 245| 2.22k| __p = g_##func##_n (__n, __s); \ | | | | 246| 2.22k| __p; \ | | | | 247| 2.22k| })) | | ------------------ ------------------ 456| 2.22k| g_ref_count_init(&self->refcount); 457| 2.22k| self->kind = FU_CBOR_ITEM_KIND_STRING; 458| 2.22k| self->value = g_strdup(value); 459| 2.22k| self->value_destroy = g_free; 460| 2.22k| return self; 461| 2.22k|} fu_cbor_item_new_bytes: 475| 3.22k|{ 476| | FuCborItem *self = g_new0(FuCborItem, 1); ------------------ | | 307| 3.22k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 3.22k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.22k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 3.22k| gsize __n = (gsize) (n_structs); \ | | | | 237| 3.22k| gsize __s = sizeof (struct_type); \ | | | | 238| 3.22k| gpointer __p; \ | | | | 239| 3.22k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 3.22k] | | | | ------------------ | | | | 240| 3.22k| __p = g_##func (__n); \ | | | | 241| 3.22k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 3.22k, False: 0] | | | | ------------------ | | | | 242| 3.22k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 3.22k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 3.22k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 3.22k] | | | | | Branch (242:26): [True: 3.22k, False: 0] | | | | ------------------ | | | | 243| 3.22k| __p = g_##func (__n * __s); \ | | | | 244| 3.22k| else \ | | | | 245| 3.22k| __p = g_##func##_n (__n, __s); \ | | | | 246| 3.22k| __p; \ | | | | 247| 3.22k| })) | | ------------------ ------------------ 477| 3.22k| g_ref_count_init(&self->refcount); 478| 3.22k| self->kind = FU_CBOR_ITEM_KIND_BYTES; 479| 3.22k| self->value = g_bytes_ref(value); 480| 3.22k| self->value_destroy = (GDestroyNotify)g_bytes_unref; 481| 3.22k| return self; 482| 3.22k|} fu_cbor_item_new_string_steal: 487| 2.58k|{ 488| | FuCborItem *self = g_new0(FuCborItem, 1); ------------------ | | 307| 2.58k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2.58k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2.58k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2.58k| gsize __n = (gsize) (n_structs); \ | | | | 237| 2.58k| gsize __s = sizeof (struct_type); \ | | | | 238| 2.58k| gpointer __p; \ | | | | 239| 2.58k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2.58k] | | | | ------------------ | | | | 240| 2.58k| __p = g_##func (__n); \ | | | | 241| 2.58k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 2.58k, False: 0] | | | | ------------------ | | | | 242| 2.58k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 2.58k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 2.58k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 2.58k] | | | | | Branch (242:26): [True: 2.58k, False: 0] | | | | ------------------ | | | | 243| 2.58k| __p = g_##func (__n * __s); \ | | | | 244| 2.58k| else \ | | | | 245| 2.58k| __p = g_##func##_n (__n, __s); \ | | | | 246| 2.58k| __p; \ | | | | 247| 2.58k| })) | | ------------------ ------------------ 489| 2.58k| g_ref_count_init(&self->refcount); 490| 2.58k| self->kind = FU_CBOR_ITEM_KIND_STRING; 491| 2.58k| self->value = value; 492| 2.58k| self->value_destroy = g_free; 493| 2.58k| return self; 494| 2.58k|} fu_cbor_item_new_integer: 508| 87.7k|{ 509| 87.7k| FuCborItem *self = g_new0(FuCborItem, 1); ------------------ | | 307| 87.7k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 87.7k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 87.7k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 87.7k| gsize __n = (gsize) (n_structs); \ | | | | 237| 87.7k| gsize __s = sizeof (struct_type); \ | | | | 238| 87.7k| gpointer __p; \ | | | | 239| 87.7k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 87.7k] | | | | ------------------ | | | | 240| 87.7k| __p = g_##func (__n); \ | | | | 241| 87.7k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 87.7k, False: 0] | | | | ------------------ | | | | 242| 87.7k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 87.7k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 87.7k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 87.7k] | | | | | Branch (242:26): [True: 87.7k, False: 0] | | | | ------------------ | | | | 243| 87.7k| __p = g_##func (__n * __s); \ | | | | 244| 87.7k| else \ | | | | 245| 87.7k| __p = g_##func##_n (__n, __s); \ | | | | 246| 87.7k| __p; \ | | | | 247| 87.7k| })) | | ------------------ ------------------ 510| 87.7k| g_ref_count_init(&self->refcount); 511| 87.7k| self->kind = FU_CBOR_ITEM_KIND_INTEGER; 512| | self->value = g_new0(gint64, 1); ------------------ | | 307| 87.7k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 87.7k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 87.7k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 87.7k| gsize __n = (gsize) (n_structs); \ | | | | 237| 87.7k| gsize __s = sizeof (struct_type); \ | | | | 238| 87.7k| gpointer __p; \ | | | | 239| 87.7k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 87.7k] | | | | ------------------ | | | | 240| 87.7k| __p = g_##func (__n); \ | | | | 241| 87.7k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 87.7k, False: 0] | | | | ------------------ | | | | 242| 87.7k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 87.7k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 87.7k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 87.7k] | | | | | Branch (242:26): [True: 87.7k, False: 0] | | | | ------------------ | | | | 243| 87.7k| __p = g_##func (__n * __s); \ | | | | 244| 87.7k| else \ | | | | 245| 87.7k| __p = g_##func##_n (__n, __s); \ | | | | 246| 87.7k| __p; \ | | | | 247| 87.7k| })) | | ------------------ ------------------ 513| 87.7k| self->value_destroy = g_free; 514| 87.7k| *((gint64 *)self->value) = value; 515| 87.7k| return self; 516| 87.7k|} fu_cbor_item_new_boolean: 530| 2.60k|{ 531| 2.60k| FuCborItem *self = g_new0(FuCborItem, 1); ------------------ | | 307| 2.60k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2.60k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2.60k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2.60k| gsize __n = (gsize) (n_structs); \ | | | | 237| 2.60k| gsize __s = sizeof (struct_type); \ | | | | 238| 2.60k| gpointer __p; \ | | | | 239| 2.60k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2.60k] | | | | ------------------ | | | | 240| 2.60k| __p = g_##func (__n); \ | | | | 241| 2.60k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 2.60k, False: 0] | | | | ------------------ | | | | 242| 2.60k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 2.60k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 2.60k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 2.60k] | | | | | Branch (242:26): [True: 2.60k, False: 0] | | | | ------------------ | | | | 243| 2.60k| __p = g_##func (__n * __s); \ | | | | 244| 2.60k| else \ | | | | 245| 2.60k| __p = g_##func##_n (__n, __s); \ | | | | 246| 2.60k| __p; \ | | | | 247| 2.60k| })) | | ------------------ ------------------ 532| 2.60k| g_ref_count_init(&self->refcount); 533| 2.60k| self->kind = FU_CBOR_ITEM_KIND_BOOLEAN; 534| 2.60k| self->value = GUINT_TO_POINTER(value); ------------------ | | 102| 2.60k|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 535| 2.60k| return self; 536| 2.60k|} fu_cbor_item_new_map: 557| 24.1k|{ 558| | FuCborItem *self = g_new0(FuCborItem, 1); ------------------ | | 307| 24.1k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 24.1k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 24.1k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 24.1k| gsize __n = (gsize) (n_structs); \ | | | | 237| 24.1k| gsize __s = sizeof (struct_type); \ | | | | 238| 24.1k| gpointer __p; \ | | | | 239| 24.1k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 24.1k] | | | | ------------------ | | | | 240| 24.1k| __p = g_##func (__n); \ | | | | 241| 24.1k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 24.1k, False: 0] | | | | ------------------ | | | | 242| 24.1k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 24.1k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 24.1k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 24.1k] | | | | | Branch (242:26): [True: 24.1k, False: 0] | | | | ------------------ | | | | 243| 24.1k| __p = g_##func (__n * __s); \ | | | | 244| 24.1k| else \ | | | | 245| 24.1k| __p = g_##func##_n (__n, __s); \ | | | | 246| 24.1k| __p; \ | | | | 247| 24.1k| })) | | ------------------ ------------------ 559| 24.1k| g_ref_count_init(&self->refcount); 560| 24.1k| self->kind = FU_CBOR_ITEM_KIND_MAP; 561| 24.1k| self->value = g_ptr_array_new_with_free_func((GDestroyNotify)fu_cbor_item_map_pair_free); 562| 24.1k| self->value_destroy = (GDestroyNotify)g_ptr_array_unref; 563| 24.1k| return self; 564| 24.1k|} fu_cbor_item_new_array: 577| 5.01k|{ 578| | FuCborItem *self = g_new0(FuCborItem, 1); ------------------ | | 307| 5.01k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 5.01k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 5.01k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 5.01k| gsize __n = (gsize) (n_structs); \ | | | | 237| 5.01k| gsize __s = sizeof (struct_type); \ | | | | 238| 5.01k| gpointer __p; \ | | | | 239| 5.01k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 5.01k] | | | | ------------------ | | | | 240| 5.01k| __p = g_##func (__n); \ | | | | 241| 5.01k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 5.01k, False: 0] | | | | ------------------ | | | | 242| 5.01k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 5.01k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 5.01k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 5.01k] | | | | | Branch (242:26): [True: 5.01k, False: 0] | | | | ------------------ | | | | 243| 5.01k| __p = g_##func (__n * __s); \ | | | | 244| 5.01k| else \ | | | | 245| 5.01k| __p = g_##func##_n (__n, __s); \ | | | | 246| 5.01k| __p; \ | | | | 247| 5.01k| })) | | ------------------ ------------------ 579| 5.01k| g_ref_count_init(&self->refcount); 580| 5.01k| self->kind = FU_CBOR_ITEM_KIND_ARRAY; 581| 5.01k| self->value = g_ptr_array_new_with_free_func((GDestroyNotify)fu_cbor_item_unref); 582| 5.01k| self->value_destroy = (GDestroyNotify)g_ptr_array_unref; 583| 5.01k| return self; 584| 5.01k|} fu_cbor_item_array_append: 600| 21.4k|{ 601| 21.4k| g_return_val_if_fail(self != NULL, FALSE); ------------------ | | 643| 21.4k| G_STMT_START { \ | | ------------------ | | | | 874| 21.4k|#define G_STMT_START do | | ------------------ | | 644| 21.4k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 21.4k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 21.4k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 21.4k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 21.4k| int _g_boolean_var_; \ | | | | | | 1018| 21.4k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 21.4k, False: 0] | | | | | | ------------------ | | | | | | 1019| 21.4k| _g_boolean_var_ = 1; \ | | | | | | 1020| 21.4k| else \ | | | | | | 1021| 21.4k| _g_boolean_var_ = 0; \ | | | | | | 1022| 21.4k| _g_boolean_var_; \ | | | | | | 1023| 21.4k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 21.4k, False: 0] | | | | ------------------ | | ------------------ | | 645| 21.4k| { } \ | | 646| 21.4k| else \ | | 647| 21.4k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 21.4k| } G_STMT_END | | ------------------ | | | | 882| 21.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 21.4k] | | | | ------------------ | | ------------------ ------------------ 602| 21.4k| g_return_val_if_fail(item != NULL, FALSE); ------------------ | | 643| 21.4k| G_STMT_START { \ | | ------------------ | | | | 874| 21.4k|#define G_STMT_START do | | ------------------ | | 644| 21.4k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 21.4k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 21.4k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 21.4k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 21.4k| int _g_boolean_var_; \ | | | | | | 1018| 21.4k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 21.4k, False: 0] | | | | | | ------------------ | | | | | | 1019| 21.4k| _g_boolean_var_ = 1; \ | | | | | | 1020| 21.4k| else \ | | | | | | 1021| 21.4k| _g_boolean_var_ = 0; \ | | | | | | 1022| 21.4k| _g_boolean_var_; \ | | | | | | 1023| 21.4k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 21.4k, False: 0] | | | | ------------------ | | ------------------ | | 645| 21.4k| { } \ | | 646| 21.4k| else \ | | 647| 21.4k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 21.4k| } G_STMT_END | | ------------------ | | | | 882| 21.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 21.4k] | | | | ------------------ | | ------------------ ------------------ 603| 21.4k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 21.4k| G_STMT_START { \ | | ------------------ | | | | 874| 21.4k|#define G_STMT_START do | | ------------------ | | 644| 21.4k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 21.4k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 21.4k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 21.4k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 21.4k| int _g_boolean_var_; \ | | | | | | 1018| 42.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 21.4k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 21.4k| _g_boolean_var_ = 1; \ | | | | | | 1020| 21.4k| else \ | | | | | | 1021| 21.4k| _g_boolean_var_ = 0; \ | | | | | | 1022| 21.4k| _g_boolean_var_; \ | | | | | | 1023| 21.4k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 21.4k, False: 0] | | | | ------------------ | | ------------------ | | 645| 21.4k| { } \ | | 646| 21.4k| else \ | | 647| 21.4k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 21.4k| } G_STMT_END | | ------------------ | | | | 882| 21.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 21.4k] | | | | ------------------ | | ------------------ ------------------ 604| | 605| | /* sanity check */ 606| 21.4k| if (self->kind != FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (606:6): [True: 0, False: 21.4k] ------------------ 607| 0| g_set_error(error, 608| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 609| 0| FWUPD_ERROR_NOT_SUPPORTED, 610| 0| "item kind invalid, got %s", 611| 0| fu_cbor_item_kind_to_string(self->kind)); 612| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 613| 0| } 614| 21.4k| g_ptr_array_add(FU_CBOR_ITEM_TO_ARRAY(self), fu_cbor_item_ref(item)); ------------------ | | 28| 21.4k|#define FU_CBOR_ITEM_TO_ARRAY(self) ((GPtrArray *)self->value) ------------------ 615| 21.4k| return TRUE; ------------------ | | 818| 21.4k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 21.4k|#define FALSE (0) | | ------------------ ------------------ 616| 21.4k|} fu_cbor_item_map_append: 636| 50.7k|{ 637| 50.7k| g_autofree FuCborPair *pair = g_new0(FuCborPair, 1); ------------------ | | 1167| 50.7k|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 50.7k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ g_autofree FuCborPair *pair = g_new0(FuCborPair, 1); ------------------ | | 307| 50.7k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 50.7k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 50.7k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 50.7k| gsize __n = (gsize) (n_structs); \ | | | | 237| 50.7k| gsize __s = sizeof (struct_type); \ | | | | 238| 50.7k| gpointer __p; \ | | | | 239| 50.7k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 50.7k] | | | | ------------------ | | | | 240| 50.7k| __p = g_##func (__n); \ | | | | 241| 50.7k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 50.7k, False: 0] | | | | ------------------ | | | | 242| 50.7k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 50.7k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 50.7k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 50.7k] | | | | | Branch (242:26): [True: 50.7k, False: 0] | | | | ------------------ | | | | 243| 50.7k| __p = g_##func (__n * __s); \ | | | | 244| 50.7k| else \ | | | | 245| 50.7k| __p = g_##func##_n (__n, __s); \ | | | | 246| 50.7k| __p; \ | | | | 247| 50.7k| })) | | ------------------ ------------------ 638| 50.7k| g_return_val_if_fail(self != NULL, FALSE); ------------------ | | 643| 50.7k| G_STMT_START { \ | | ------------------ | | | | 874| 50.7k|#define G_STMT_START do | | ------------------ | | 644| 50.7k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 50.7k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 50.7k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 50.7k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 50.7k| int _g_boolean_var_; \ | | | | | | 1018| 50.7k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 50.7k, False: 0] | | | | | | ------------------ | | | | | | 1019| 50.7k| _g_boolean_var_ = 1; \ | | | | | | 1020| 50.7k| else \ | | | | | | 1021| 50.7k| _g_boolean_var_ = 0; \ | | | | | | 1022| 50.7k| _g_boolean_var_; \ | | | | | | 1023| 50.7k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 50.7k, False: 0] | | | | ------------------ | | ------------------ | | 645| 50.7k| { } \ | | 646| 50.7k| else \ | | 647| 50.7k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 50.7k| } G_STMT_END | | ------------------ | | | | 882| 50.7k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 50.7k] | | | | ------------------ | | ------------------ ------------------ 639| 50.7k| g_return_val_if_fail(item_key != NULL, FALSE); ------------------ | | 643| 50.7k| G_STMT_START { \ | | ------------------ | | | | 874| 50.7k|#define G_STMT_START do | | ------------------ | | 644| 50.7k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 50.7k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 50.7k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 50.7k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 50.7k| int _g_boolean_var_; \ | | | | | | 1018| 50.7k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 50.7k, False: 0] | | | | | | ------------------ | | | | | | 1019| 50.7k| _g_boolean_var_ = 1; \ | | | | | | 1020| 50.7k| else \ | | | | | | 1021| 50.7k| _g_boolean_var_ = 0; \ | | | | | | 1022| 50.7k| _g_boolean_var_; \ | | | | | | 1023| 50.7k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 50.7k, False: 0] | | | | ------------------ | | ------------------ | | 645| 50.7k| { } \ | | 646| 50.7k| else \ | | 647| 50.7k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 50.7k| } G_STMT_END | | ------------------ | | | | 882| 50.7k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 50.7k] | | | | ------------------ | | ------------------ ------------------ 640| 50.7k| g_return_val_if_fail(item_val != NULL, FALSE); ------------------ | | 643| 50.7k| G_STMT_START { \ | | ------------------ | | | | 874| 50.7k|#define G_STMT_START do | | ------------------ | | 644| 50.7k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 50.7k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 50.7k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 50.7k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 50.7k| int _g_boolean_var_; \ | | | | | | 1018| 50.7k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 50.7k, False: 0] | | | | | | ------------------ | | | | | | 1019| 50.7k| _g_boolean_var_ = 1; \ | | | | | | 1020| 50.7k| else \ | | | | | | 1021| 50.7k| _g_boolean_var_ = 0; \ | | | | | | 1022| 50.7k| _g_boolean_var_; \ | | | | | | 1023| 50.7k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 50.7k, False: 0] | | | | ------------------ | | ------------------ | | 645| 50.7k| { } \ | | 646| 50.7k| else \ | | 647| 50.7k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 50.7k| } G_STMT_END | | ------------------ | | | | 882| 50.7k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 50.7k] | | | | ------------------ | | ------------------ ------------------ 641| 50.7k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 50.7k| G_STMT_START { \ | | ------------------ | | | | 874| 50.7k|#define G_STMT_START do | | ------------------ | | 644| 50.7k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 50.7k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 50.7k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 50.7k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 50.7k| int _g_boolean_var_; \ | | | | | | 1018| 101k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 50.7k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 50.7k| _g_boolean_var_ = 1; \ | | | | | | 1020| 50.7k| else \ | | | | | | 1021| 50.7k| _g_boolean_var_ = 0; \ | | | | | | 1022| 50.7k| _g_boolean_var_; \ | | | | | | 1023| 50.7k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 50.7k, False: 0] | | | | ------------------ | | ------------------ | | 645| 50.7k| { } \ | | 646| 50.7k| else \ | | 647| 50.7k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCbor" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 50.7k| } G_STMT_END | | ------------------ | | | | 882| 50.7k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 50.7k] | | | | ------------------ | | ------------------ ------------------ 642| | 643| | /* sanity check */ 644| 50.7k| if (self->kind != FU_CBOR_ITEM_KIND_MAP) { ------------------ | Branch (644:6): [True: 0, False: 50.7k] ------------------ 645| 0| g_set_error(error, 646| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 647| 0| FWUPD_ERROR_NOT_SUPPORTED, 648| 0| "item kind invalid, got %s", 649| 0| fu_cbor_item_kind_to_string(self->kind)); 650| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 651| 0| } 652| | 653| 50.7k| pair->key = fu_cbor_item_ref(item_key); 654| 50.7k| pair->val = fu_cbor_item_ref(item_val); 655| 50.7k| g_ptr_array_add(FU_CBOR_ITEM_TO_ARRAY(self), g_steal_pointer(&pair)); ------------------ | | 28| 50.7k|#define FU_CBOR_ITEM_TO_ARRAY(self) ((GPtrArray *)self->value) ------------------ g_ptr_array_add(FU_CBOR_ITEM_TO_ARRAY(self), g_steal_pointer(&pair)); ------------------ | | 222| 50.7k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 656| 50.7k| return TRUE; ------------------ | | 818| 50.7k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 50.7k|#define FALSE (0) | | ------------------ ------------------ 657| 50.7k|} fu-cbor-item.c:fu_cbor_item_append: 295| 26.9k|{ 296| 26.9k| if (self->kind == FU_CBOR_ITEM_KIND_INTEGER) { ------------------ | Branch (296:6): [True: 15.6k, False: 11.2k] ------------------ 297| 15.6k| gint64 value = FU_CBOR_ITEM_TO_INT64(self); ------------------ | | 31| 15.6k|#define FU_CBOR_ITEM_TO_INT64(self) (*((gint64 *)self->value)) ------------------ 298| 15.6k| if (value >= 0) { ------------------ | Branch (298:7): [True: 15.6k, False: 82] ------------------ 299| 15.6k| fu_cbor_item_append_extended(buf, FU_CBOR_TAG_POS_INT, value); 300| 15.6k| } else { 301| 82| fu_cbor_item_append_extended(buf, FU_CBOR_TAG_NEG_INT, -1 - value); 302| 82| } 303| 15.6k| return TRUE; ------------------ | | 818| 15.6k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 15.6k|#define FALSE (0) | | ------------------ ------------------ 304| 15.6k| } 305| 11.2k| if (self->kind == FU_CBOR_ITEM_KIND_BOOLEAN) { ------------------ | Branch (305:6): [True: 761, False: 10.4k] ------------------ 306| 761| gboolean value = FU_CBOR_ITEM_TO_BOOLEAN(self); ------------------ | | 32| 761|#define FU_CBOR_ITEM_TO_BOOLEAN(self) (GPOINTER_TO_UINT(self->value)) | | ------------------ | | | | 99| 761|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) | | ------------------ ------------------ 307| 761| fu_cbor_item_append_extended(buf, 308| 761| FU_CBOR_TAG_SPECIAL, 309| 761| value ? FU_CBOR_SPECIAL_VALUE_TRUE ------------------ | Branch (309:11): [True: 761, False: 0] ------------------ 310| 761| : FU_CBOR_SPECIAL_VALUE_FALSE); 311| 761| return TRUE; ------------------ | | 818| 761|#define TRUE (!FALSE) | | ------------------ | | | | 814| 761|#define FALSE (0) | | ------------------ ------------------ 312| 761| } 313| 10.4k| if (self->kind == FU_CBOR_ITEM_KIND_STRING) { ------------------ | Branch (313:6): [True: 2.00k, False: 8.48k] ------------------ 314| 2.00k| const gchar *str = FU_CBOR_ITEM_TO_STRING(self); ------------------ | | 30| 2.00k|#define FU_CBOR_ITEM_TO_STRING(self) ((gchar *)self->value) ------------------ 315| 2.00k| gsize strsz; 316| 2.00k| if (str == NULL) { ------------------ | Branch (316:7): [True: 0, False: 2.00k] ------------------ 317| 0| fu_cbor_item_append_extended(buf, 318| 0| FU_CBOR_TAG_SPECIAL, 319| 0| FU_CBOR_SPECIAL_VALUE_NULL); 320| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 321| 0| } 322| 2.00k| strsz = strlen(str); 323| 2.00k| fu_cbor_item_append_extended(buf, FU_CBOR_TAG_STRING, strsz); 324| 2.00k| if (strsz > 0) ------------------ | Branch (324:7): [True: 2.00k, False: 0] ------------------ 325| 2.00k| g_byte_array_append(buf, (const guint8 *)str, strsz); 326| 2.00k| return TRUE; ------------------ | | 818| 2.00k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 2.00k|#define FALSE (0) | | ------------------ ------------------ 327| 2.00k| } 328| 8.48k| if (self->kind == FU_CBOR_ITEM_KIND_BYTES) { ------------------ | Branch (328:6): [True: 313, False: 8.17k] ------------------ 329| 313| GBytes *blob = FU_CBOR_ITEM_TO_BYTES(self); ------------------ | | 29| 313|#define FU_CBOR_ITEM_TO_BYTES(self) ((GBytes *)self->value) ------------------ 330| 313| fu_cbor_item_append_extended(buf, FU_CBOR_TAG_BYTES, g_bytes_get_size(blob)); 331| 313| if (g_bytes_get_size(blob) > 0) ------------------ | Branch (331:7): [True: 313, False: 0] ------------------ 332| 313| fu_byte_array_append_bytes(buf, blob); 333| 313| return TRUE; ------------------ | | 818| 313|#define TRUE (!FALSE) | | ------------------ | | | | 814| 313|#define FALSE (0) | | ------------------ ------------------ 334| 313| } 335| 8.17k| if (self->kind == FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (335:6): [True: 966, False: 7.20k] ------------------ 336| 966| GPtrArray *array = FU_CBOR_ITEM_TO_ARRAY(self); ------------------ | | 28| 966|#define FU_CBOR_ITEM_TO_ARRAY(self) ((GPtrArray *)self->value) ------------------ 337| 966| fu_cbor_item_append_extended(buf, FU_CBOR_TAG_ARRAY, array->len); 338| 6.90k| for (guint i = 0; i < array->len; i++) { ------------------ | Branch (338:21): [True: 5.93k, False: 966] ------------------ 339| 5.93k| FuCborItem *item_tmp = g_ptr_array_index(array, i); ------------------ | | 138| 5.93k|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 340| 5.93k| if (!fu_cbor_item_append(item_tmp, buf, error)) ------------------ | Branch (340:8): [True: 0, False: 5.93k] ------------------ 341| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 342| 5.93k| } 343| 966| return TRUE; ------------------ | | 818| 966|#define TRUE (!FALSE) | | ------------------ | | | | 814| 966|#define FALSE (0) | | ------------------ ------------------ 344| 966| } 345| 7.20k| if (self->kind == FU_CBOR_ITEM_KIND_MAP) { ------------------ | Branch (345:6): [True: 7.20k, False: 0] ------------------ 346| 7.20k| GPtrArray *array = FU_CBOR_ITEM_TO_ARRAY(self); ------------------ | | 28| 7.20k|#define FU_CBOR_ITEM_TO_ARRAY(self) ((GPtrArray *)self->value) ------------------ 347| 7.20k| fu_cbor_item_append_extended(buf, FU_CBOR_TAG_MAP, array->len); 348| 17.3k| for (guint i = 0; i < array->len; i++) { ------------------ | Branch (348:21): [True: 10.1k, False: 7.20k] ------------------ 349| 10.1k| FuCborPair *pair = g_ptr_array_index(array, i); ------------------ | | 138| 10.1k|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 350| 10.1k| if (!fu_cbor_item_append(pair->key, buf, error)) ------------------ | Branch (350:8): [True: 0, False: 10.1k] ------------------ 351| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 352| 10.1k| if (!fu_cbor_item_append(pair->val, buf, error)) ------------------ | Branch (352:8): [True: 0, False: 10.1k] ------------------ 353| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 354| 10.1k| } 355| 7.20k| return TRUE; ------------------ | | 818| 7.20k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 7.20k|#define FALSE (0) | | ------------------ ------------------ 356| 7.20k| } 357| | 358| | /* failed */ 359| 0| g_set_error(error, 360| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 361| 0| FWUPD_ERROR_NOT_SUPPORTED, 362| 0| "item kind %s write unsupported", 363| 0| fu_cbor_item_kind_to_string(self->kind)); 364| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 365| 7.20k|} fu-cbor-item.c:fu_cbor_item_append_extended: 275| 26.9k|{ 276| 26.9k| if (value <= FU_CBOR_LEN_SHORT_MAX) { ------------------ | Branch (276:6): [True: 20.4k, False: 6.51k] ------------------ 277| 20.4k| fu_cbor_item_append_raw(buf, tag, value); 278| 20.4k| } else if (value <= G_MAXUINT8) { ------------------ | | 70| 6.51k|#define G_MAXUINT8 ((guint8) 0xff) ------------------ | Branch (278:13): [True: 5.45k, False: 1.06k] ------------------ 279| 5.45k| fu_cbor_item_append_raw(buf, tag, FU_CBOR_LEN_EXT8); 280| 5.45k| fu_byte_array_append_uint8(buf, value); 281| 5.45k| } else if (value <= G_MAXUINT16) { ------------------ | | 81| 1.06k|#define G_MAXUINT16 ((guint16) 0xffff) ------------------ | Branch (281:13): [True: 723, False: 343] ------------------ 282| 723| fu_cbor_item_append_raw(buf, tag, FU_CBOR_LEN_EXT16); 283| 723| fu_byte_array_append_uint16(buf, value, G_BIG_ENDIAN); ------------------ | | 185| 723|#define G_BIG_ENDIAN 4321 ------------------ 284| 723| } else if (value <= G_MAXUINT32) { ------------------ | | 92| 343|#define G_MAXUINT32 ((guint32) 0xffffffff) ------------------ | Branch (284:13): [True: 274, False: 69] ------------------ 285| 274| fu_cbor_item_append_raw(buf, tag, FU_CBOR_LEN_EXT32); 286| 274| fu_byte_array_append_uint32(buf, value, G_BIG_ENDIAN); ------------------ | | 185| 274|#define G_BIG_ENDIAN 4321 ------------------ 287| 274| } else { 288| 69| fu_cbor_item_append_raw(buf, tag, FU_CBOR_LEN_EXT64); 289| 69| fu_byte_array_append_uint64(buf, value, G_BIG_ENDIAN); ------------------ | | 185| 69|#define G_BIG_ENDIAN 4321 ------------------ 290| 69| } 291| 26.9k|} fu-cbor-item.c:fu_cbor_item_append_raw: 269| 26.9k|{ 270| 26.9k| fu_byte_array_append_uint8(buf, (tag << 5) | value); 271| 26.9k|} fu-cbor-item.c:fu_cbor_item_map_pair_free: 540| 50.7k|{ 541| 50.7k| fu_cbor_item_unref(pair->key); 542| 50.7k| fu_cbor_item_unref(pair->val); 543| 50.7k| g_free(pair); 544| 50.7k|} fu_size_checked_add: 33| 114k|{ 34| 114k| gsize tmp = 0; 35| 114k| if (!g_size_checked_add(&tmp, a, b)) ------------------ | | 444| 114k| _GLIB_CHECKED_ADD_U64(dest, a, b) ------------------ | Branch (35:6): [True: 0, False: 114k] ------------------ 36| 0| return G_MAXSIZE; ------------------ | | 84| 0|#define G_MAXSIZE G_MAXULONG | | ------------------ | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | ------------------ ------------------ 37| 114k| return tmp; 38| 114k|} fu_size_checked_inc: 56| 119k|{ 57| 119k| gsize value_new; 58| | 59| 119k| g_return_val_if_fail(value != NULL, FALSE); ------------------ | | 643| 119k| G_STMT_START { \ | | ------------------ | | | | 874| 119k|#define G_STMT_START do | | ------------------ | | 644| 119k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 119k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 119k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 119k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 119k| int _g_boolean_var_; \ | | | | | | 1018| 119k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 119k, False: 0] | | | | | | ------------------ | | | | | | 1019| 119k| _g_boolean_var_ = 1; \ | | | | | | 1020| 119k| else \ | | | | | | 1021| 119k| _g_boolean_var_ = 0; \ | | | | | | 1022| 119k| _g_boolean_var_; \ | | | | | | 1023| 119k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 119k, False: 0] | | | | ------------------ | | ------------------ | | 645| 119k| { } \ | | 646| 119k| else \ | | 647| 119k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCommon" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 119k| } G_STMT_END | | ------------------ | | | | 882| 119k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 119k] | | | | ------------------ | | ------------------ ------------------ 60| 119k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 119k| G_STMT_START { \ | | ------------------ | | | | 874| 119k|#define G_STMT_START do | | ------------------ | | 644| 119k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 119k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 119k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 119k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 119k| int _g_boolean_var_; \ | | | | | | 1018| 239k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 119k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 119k| _g_boolean_var_ = 1; \ | | | | | | 1020| 119k| else \ | | | | | | 1021| 119k| _g_boolean_var_ = 0; \ | | | | | | 1022| 119k| _g_boolean_var_; \ | | | | | | 1023| 119k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 119k, False: 0] | | | | ------------------ | | ------------------ | | 645| 119k| { } \ | | 646| 119k| else \ | | 647| 119k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCommon" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 119k| } G_STMT_END | | ------------------ | | | | 882| 119k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 119k] | | | | ------------------ | | ------------------ ------------------ 61| | 62| 119k| value_new = *value; 63| 119k| if (!g_size_checked_add(&value_new, *value, len)) { ------------------ | | 444| 119k| _GLIB_CHECKED_ADD_U64(dest, a, b) ------------------ | Branch (63:6): [True: 0, False: 119k] ------------------ 64| 0| g_set_error(error, 65| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 66| 0| FWUPD_ERROR_INVALID_DATA, 67| 0| "0x%" G_GSIZE_MODIFIER "x + 0x%" G_GSIZE_MODIFIER "x would overflow", 68| 0| *value, 69| 0| len); 70| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 71| 0| } 72| | 73| | /* success */ 74| 119k| *value = value_new; 75| 119k| return TRUE; ------------------ | | 818| 119k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 119k|#define FALSE (0) | | ------------------ ------------------ 76| 119k|} fu_coswid_read_string: 27| 1.53k|{ 28| 1.53k| g_return_val_if_fail(item != NULL, NULL); ------------------ | | 643| 1.53k| G_STMT_START { \ | | ------------------ | | | | 874| 1.53k|#define G_STMT_START do | | ------------------ | | 644| 1.53k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1.53k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1.53k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1.53k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1.53k| int _g_boolean_var_; \ | | | | | | 1018| 1.53k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1.53k, False: 0] | | | | | | ------------------ | | | | | | 1019| 1.53k| _g_boolean_var_ = 1; \ | | | | | | 1020| 1.53k| else \ | | | | | | 1021| 1.53k| _g_boolean_var_ = 0; \ | | | | | | 1022| 1.53k| _g_boolean_var_; \ | | | | | | 1023| 1.53k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1.53k, False: 0] | | | | ------------------ | | ------------------ | | 645| 1.53k| { } \ | | 646| 1.53k| else \ | | 647| 1.53k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1.53k| } G_STMT_END | | ------------------ | | | | 882| 1.53k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1.53k] | | | | ------------------ | | ------------------ ------------------ 29| 1.53k| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 1.53k| G_STMT_START { \ | | ------------------ | | | | 874| 1.53k|#define G_STMT_START do | | ------------------ | | 644| 1.53k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1.53k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1.53k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1.53k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1.53k| int _g_boolean_var_; \ | | | | | | 1018| 3.07k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1.53k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 1.53k| _g_boolean_var_ = 1; \ | | | | | | 1020| 1.53k| else \ | | | | | | 1021| 1.53k| _g_boolean_var_ = 0; \ | | | | | | 1022| 1.53k| _g_boolean_var_; \ | | | | | | 1023| 1.53k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1.53k, False: 0] | | | | ------------------ | | ------------------ | | 645| 1.53k| { } \ | | 646| 1.53k| else \ | | 647| 1.53k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1.53k| } G_STMT_END | | ------------------ | | | | 882| 1.53k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1.53k] | | | | ------------------ | | ------------------ ------------------ 30| | 31| 1.53k| if (fu_cbor_item_get_kind(item) == FU_CBOR_ITEM_KIND_STRING) ------------------ | Branch (31:6): [True: 1.09k, False: 445] ------------------ 32| 1.09k| return fu_cbor_item_get_string(item, error); 33| 445| if (fu_cbor_item_get_kind(item) == FU_CBOR_ITEM_KIND_BYTES) { ------------------ | Branch (33:6): [True: 355, False: 90] ------------------ 34| 355| g_autoptr(GBytes) blob = fu_cbor_item_get_bytes(item, error); ------------------ | | 1162| 355|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 355|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 35| 355| if (blob == NULL) ------------------ | Branch (35:7): [True: 0, False: 355] ------------------ 36| 0| return NULL; 37| 355| if (g_bytes_get_size(blob) == 16) { ------------------ | Branch (37:7): [True: 339, False: 16] ------------------ 38| 339| return fwupd_guid_to_string( 39| 339| (const fwupd_guid_t *)g_bytes_get_data(blob, NULL), 40| 339| FWUPD_GUID_FLAG_NONE); 41| 339| } 42| 355| } 43| 106| g_set_error_literal(error, 44| 106| FWUPD_ERROR, ------------------ | | 15| 106|#define FWUPD_ERROR fwupd_error_quark() ------------------ 45| 106| FWUPD_ERROR_INVALID_DATA, 46| 106| "item is not a string or GUID bytestring"); 47| | return NULL; 48| 445|} fu_coswid_read_tag: 64| 32.9k|{ 65| 32.9k| gint64 tmp = 0; 66| | 67| 32.9k| g_return_val_if_fail(item != NULL, FALSE); ------------------ | | 643| 32.9k| G_STMT_START { \ | | ------------------ | | | | 874| 32.9k|#define G_STMT_START do | | ------------------ | | 644| 32.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 32.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 32.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 32.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 32.9k| int _g_boolean_var_; \ | | | | | | 1018| 32.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 32.9k, False: 0] | | | | | | ------------------ | | | | | | 1019| 32.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 32.9k| else \ | | | | | | 1021| 32.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 32.9k| _g_boolean_var_; \ | | | | | | 1023| 32.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 32.9k, False: 0] | | | | ------------------ | | ------------------ | | 645| 32.9k| { } \ | | 646| 32.9k| else \ | | 647| 32.9k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 32.9k| } G_STMT_END | | ------------------ | | | | 882| 32.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 32.9k] | | | | ------------------ | | ------------------ ------------------ 68| 32.9k| g_return_val_if_fail(value != NULL, FALSE); ------------------ | | 643| 32.9k| G_STMT_START { \ | | ------------------ | | | | 874| 32.9k|#define G_STMT_START do | | ------------------ | | 644| 32.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 32.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 32.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 32.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 32.9k| int _g_boolean_var_; \ | | | | | | 1018| 32.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 32.9k, False: 0] | | | | | | ------------------ | | | | | | 1019| 32.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 32.9k| else \ | | | | | | 1021| 32.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 32.9k| _g_boolean_var_; \ | | | | | | 1023| 32.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 32.9k, False: 0] | | | | ------------------ | | ------------------ | | 645| 32.9k| { } \ | | 646| 32.9k| else \ | | 647| 32.9k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 32.9k| } G_STMT_END | | ------------------ | | | | 882| 32.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 32.9k] | | | | ------------------ | | ------------------ ------------------ 69| 32.9k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 32.9k| G_STMT_START { \ | | ------------------ | | | | 874| 32.9k|#define G_STMT_START do | | ------------------ | | 644| 32.9k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 32.9k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 32.9k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 32.9k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 32.9k| int _g_boolean_var_; \ | | | | | | 1018| 65.8k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 32.9k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 32.9k| _g_boolean_var_ = 1; \ | | | | | | 1020| 32.9k| else \ | | | | | | 1021| 32.9k| _g_boolean_var_ = 0; \ | | | | | | 1022| 32.9k| _g_boolean_var_; \ | | | | | | 1023| 32.9k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 32.9k, False: 0] | | | | ------------------ | | ------------------ | | 645| 32.9k| { } \ | | 646| 32.9k| else \ | | 647| 32.9k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 32.9k| } G_STMT_END | | ------------------ | | | | 882| 32.9k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 32.9k] | | | | ------------------ | | ------------------ ------------------ 70| | 71| 32.9k| if (!fu_cbor_item_get_integer(item, &tmp, error)) { ------------------ | Branch (71:6): [True: 58, False: 32.8k] ------------------ 72| 58| g_prefix_error_literal(error, "tag invalid: "); ------------------ | | 11| 58|#define g_prefix_error_literal g_prefix_error ------------------ 73| 58| return FALSE; ------------------ | | 814| 58|#define FALSE (0) ------------------ 74| 58| } 75| 32.8k| *value = (FuCoswidTag)tmp; 76| 32.8k| return TRUE; ------------------ | | 818| 32.8k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 32.8k|#define FALSE (0) | | ------------------ ------------------ 77| 32.9k|} fu_coswid_read_version_scheme: 93| 192|{ 94| 192| gint64 tmp = 0; 95| | 96| 192| g_return_val_if_fail(item != NULL, FALSE); ------------------ | | 643| 192| G_STMT_START { \ | | ------------------ | | | | 874| 192|#define G_STMT_START do | | ------------------ | | 644| 192| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 192|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 192| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 192|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 192| int _g_boolean_var_; \ | | | | | | 1018| 192| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 192, False: 0] | | | | | | ------------------ | | | | | | 1019| 192| _g_boolean_var_ = 1; \ | | | | | | 1020| 192| else \ | | | | | | 1021| 192| _g_boolean_var_ = 0; \ | | | | | | 1022| 192| _g_boolean_var_; \ | | | | | | 1023| 192|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 192, False: 0] | | | | ------------------ | | ------------------ | | 645| 192| { } \ | | 646| 192| else \ | | 647| 192| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 192| } G_STMT_END | | ------------------ | | | | 882| 192|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 192] | | | | ------------------ | | ------------------ ------------------ 97| 192| g_return_val_if_fail(value != NULL, FALSE); ------------------ | | 643| 192| G_STMT_START { \ | | ------------------ | | | | 874| 192|#define G_STMT_START do | | ------------------ | | 644| 192| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 192|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 192| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 192|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 192| int _g_boolean_var_; \ | | | | | | 1018| 192| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 192, False: 0] | | | | | | ------------------ | | | | | | 1019| 192| _g_boolean_var_ = 1; \ | | | | | | 1020| 192| else \ | | | | | | 1021| 192| _g_boolean_var_ = 0; \ | | | | | | 1022| 192| _g_boolean_var_; \ | | | | | | 1023| 192|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 192, False: 0] | | | | ------------------ | | ------------------ | | 645| 192| { } \ | | 646| 192| else \ | | 647| 192| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 192| } G_STMT_END | | ------------------ | | | | 882| 192|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 192] | | | | ------------------ | | ------------------ ------------------ 98| 192| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 192| G_STMT_START { \ | | ------------------ | | | | 874| 192|#define G_STMT_START do | | ------------------ | | 644| 192| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 192|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 192| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 192|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 192| int _g_boolean_var_; \ | | | | | | 1018| 384| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 192, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 192| _g_boolean_var_ = 1; \ | | | | | | 1020| 192| else \ | | | | | | 1021| 192| _g_boolean_var_ = 0; \ | | | | | | 1022| 192| _g_boolean_var_; \ | | | | | | 1023| 192|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 192, False: 0] | | | | ------------------ | | ------------------ | | 645| 192| { } \ | | 646| 192| else \ | | 647| 192| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 192| } G_STMT_END | | ------------------ | | | | 882| 192|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 192] | | | | ------------------ | | ------------------ ------------------ 99| | 100| 192| if (!fu_cbor_item_get_integer(item, &tmp, error)) { ------------------ | Branch (100:6): [True: 1, False: 191] ------------------ 101| 1| g_prefix_error_literal(error, "version-scheme invalid: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 102| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 103| 1| } 104| 191| *value = (FuCoswidVersionScheme)tmp; 105| 191| return TRUE; ------------------ | | 818| 191|#define TRUE (!FALSE) | | ------------------ | | | | 814| 191|#define FALSE (0) | | ------------------ ------------------ 106| 192|} fu_coswid_write_tag_string: 120| 2.00k|{ 121| 2.00k| g_autoptr(FuCborItem) key = fu_cbor_item_new_integer(tag); ------------------ | | 1162| 2.00k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 2.00k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 122| 2.00k| g_autoptr(FuCborItem) val = fu_cbor_item_new_string(value); ------------------ | | 1162| 2.00k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 2.00k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 123| 2.00k| if (!fu_cbor_item_map_append(item, key, val, NULL)) ------------------ | Branch (123:6): [True: 0, False: 2.00k] ------------------ 124| 0| g_critical("failed to push string to map"); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 125| 2.00k|} fu_coswid_write_tag_bytestring: 140| 46|{ 141| 46| g_autoptr(GBytes) blob = g_bytes_new(buf, bufsz); ------------------ | | 1162| 46|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 46|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 142| 46| g_autoptr(FuCborItem) key = fu_cbor_item_new_integer(tag); ------------------ | | 1162| 46|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 46|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 143| 46| g_autoptr(FuCborItem) val = fu_cbor_item_new_bytes(blob); ------------------ | | 1162| 46|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 46|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 144| 46| if (!fu_cbor_item_map_append(item, key, val, NULL)) ------------------ | Branch (144:6): [True: 0, False: 46] ------------------ 145| 0| g_critical("failed to push bytestring to map"); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 146| 46|} fu_coswid_write_tag_bool: 160| 761|{ 161| 761| g_autoptr(FuCborItem) key = fu_cbor_item_new_integer(tag); ------------------ | | 1162| 761|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 761|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 162| 761| g_autoptr(FuCborItem) val = fu_cbor_item_new_boolean(value); ------------------ | | 1162| 761|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 761|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 163| 761| if (!fu_cbor_item_map_append(item, key, val, NULL)) ------------------ | Branch (163:6): [True: 0, False: 761] ------------------ 164| 0| g_critical("failed to push bool to indefinite map"); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 165| 761|} fu_coswid_write_tag_integer: 179| 5.18k|{ 180| 5.18k| g_autoptr(FuCborItem) key = fu_cbor_item_new_integer(tag); ------------------ | | 1162| 5.18k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 5.18k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 181| 5.18k| g_autoptr(FuCborItem) val = fu_cbor_item_new_integer(value); ------------------ | | 1162| 5.18k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 5.18k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 182| 5.18k| if (!fu_cbor_item_map_append(item, key, val, NULL)) ------------------ | Branch (182:6): [True: 0, False: 5.18k] ------------------ 183| 0| g_critical("failed to push integer to map"); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 184| 5.18k|} fu_coswid_write_tag_item: 198| 2.12k|{ 199| 2.12k| g_autoptr(FuCborItem) key = fu_cbor_item_new_integer(tag); ------------------ | | 1162| 2.12k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 2.12k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 200| 2.12k| if (!fu_cbor_item_map_append(item, key, value, NULL)) ------------------ | Branch (200:6): [True: 0, False: 2.12k] ------------------ 201| 0| g_critical("failed to push item to indefinite map"); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 202| 2.12k|} fu_coswid_parse_one_or_many: 220| 4.92k|{ 221| 4.92k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 4.92k| G_STMT_START { \ | | ------------------ | | | | 874| 4.92k|#define G_STMT_START do | | ------------------ | | 644| 4.92k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 4.92k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 4.92k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 4.92k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 4.92k| int _g_boolean_var_; \ | | | | | | 1018| 9.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 4.92k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 4.92k| _g_boolean_var_ = 1; \ | | | | | | 1020| 4.92k| else \ | | | | | | 1021| 4.92k| _g_boolean_var_ = 0; \ | | | | | | 1022| 4.92k| _g_boolean_var_; \ | | | | | | 1023| 4.92k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 4.92k, False: 0] | | | | ------------------ | | ------------------ | | 645| 4.92k| { } \ | | 646| 4.92k| else \ | | 647| 4.92k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 4.92k| } G_STMT_END | | ------------------ | | | | 882| 4.92k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 4.92k] | | | | ------------------ | | ------------------ ------------------ 222| | 223| | /* one */ 224| 4.92k| if (fu_cbor_item_get_kind(item) == FU_CBOR_ITEM_KIND_MAP) ------------------ | Branch (224:6): [True: 3.89k, False: 1.03k] ------------------ 225| 3.89k| return func(item, user_data, error); 226| | 227| | /* many */ 228| 1.03k| if (fu_cbor_item_get_kind(item) == FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (228:6): [True: 1.01k, False: 21] ------------------ 229| 8.05k| for (guint j = 0; j < fu_cbor_item_array_length(item); j++) { ------------------ | Branch (229:21): [True: 7.11k, False: 937] ------------------ 230| 7.11k| FuCborItem *value = fu_cbor_item_array_index(item, j); 231| 7.11k| if (fu_cbor_item_get_kind(value) != FU_CBOR_ITEM_KIND_MAP) { ------------------ | Branch (231:8): [True: 44, False: 7.07k] ------------------ 232| 44| g_set_error_literal(error, 233| 44| FWUPD_ERROR, ------------------ | | 15| 44|#define FWUPD_ERROR fwupd_error_quark() ------------------ 234| 44| FWUPD_ERROR_INVALID_DATA, 235| 44| "not an array of a map"); 236| 44| return FALSE; ------------------ | | 814| 44|#define FALSE (0) ------------------ 237| 44| } 238| 7.07k| if (!func(value, user_data, error)) ------------------ | Branch (238:8): [True: 32, False: 7.04k] ------------------ 239| 32| return FALSE; ------------------ | | 814| 32|#define FALSE (0) ------------------ 240| 7.07k| } 241| 937| return TRUE; ------------------ | | 818| 937|#define TRUE (!FALSE) | | ------------------ | | | | 814| 937|#define FALSE (0) | | ------------------ ------------------ 242| 1.01k| } 243| | 244| | /* not sure what to do */ 245| 21| g_set_error_literal(error, 246| 21| FWUPD_ERROR, ------------------ | | 15| 21|#define FWUPD_ERROR fwupd_error_quark() ------------------ 247| 21| FWUPD_ERROR_INVALID_DATA, 248| 21| "neither an array or map"); 249| 21| return FALSE; ------------------ | | 814| 21|#define FALSE (0) ------------------ 250| 1.03k|} fu-coswid-firmware.c:fu_coswid_firmware_class_init: 1339| 1|{ 1340| 1| GObjectClass *object_class = G_OBJECT_CLASS(klass); ------------------ | | 63| 1|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 1|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 1| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 1341| 1| FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass); 1342| 1| object_class->finalize = fu_coswid_firmware_finalize; 1343| 1| firmware_class->parse = fu_coswid_firmware_parse; 1344| 1| firmware_class->write = fu_coswid_firmware_write; 1345| 1| firmware_class->build = fu_coswid_firmware_build; 1346| 1| firmware_class->export = fu_coswid_firmware_export; 1347| 1| firmware_class->get_checksum = fu_coswid_firmware_get_checksum; 1348| 1|} fu-coswid-firmware.c:fu_coswid_firmware_finalize: 1321| 3.85k|{ 1322| 3.85k| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(object); 1323| 3.85k| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 3.85k|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 1324| | 1325| 3.85k| g_free(priv->product); 1326| 3.85k| g_free(priv->summary); 1327| 3.85k| g_free(priv->colloquial_version); 1328| 3.85k| g_free(priv->persistent_id); 1329| 3.85k| g_free(priv->device_id); 1330| 3.85k| g_ptr_array_unref(priv->links); 1331| 3.85k| g_ptr_array_unref(priv->payloads); 1332| 3.85k| g_ptr_array_unref(priv->entities); 1333| | 1334| 3.85k| G_OBJECT_CLASS(fu_coswid_firmware_parent_class)->finalize(object); ------------------ | | 63| 3.85k|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 3.85k|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 3.85k| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 1335| 3.85k|} fu-coswid-firmware.c:fu_coswid_firmware_parse: 630| 3.85k|{ 631| 3.85k| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(firmware); 632| 3.85k| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 3.85k|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 633| 3.85k| gsize offset = 0; 634| 3.85k| g_autoptr(FuCborItem) item = NULL; ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 635| | 636| 3.85k| item = fu_cbor_parse(stream, 637| 3.85k| &offset, 638| 3.85k| FU_COSWID_CBOR_MAX_DEPTH, ------------------ | | 42| 3.85k|#define FU_COSWID_CBOR_MAX_DEPTH 10 ------------------ 639| 3.85k| FU_COSWID_CBOR_MAX_ITEMS, ------------------ | | 43| 3.85k|#define FU_COSWID_CBOR_MAX_ITEMS 100 ------------------ 640| 3.85k| FU_COSWID_CBOR_MAX_LENGTH, ------------------ | | 44| 3.85k|#define FU_COSWID_CBOR_MAX_LENGTH 10240 ------------------ 641| 3.85k| error); 642| 3.85k| if (item == NULL) ------------------ | Branch (642:6): [True: 1.21k, False: 2.63k] ------------------ 643| 1.21k| return FALSE; ------------------ | | 814| 1.21k|#define FALSE (0) ------------------ 644| 2.63k| fu_firmware_set_size(firmware, offset); 645| | 646| | /* pretty-print the result */ 647| 2.63k| if (g_getenv("FWUPD_CBOR_VERBOSE") != NULL) { ------------------ | Branch (647:6): [True: 0, False: 2.63k] ------------------ 648| 0| g_autofree gchar *str = fu_cbor_item_to_string(item); ------------------ | | 1167| 0|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 0|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 649| 0| g_debug("%s", str); ------------------ | | 351| 0|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 0| G_LOG_LEVEL_DEBUG, \ | | 353| 0| __VA_ARGS__) ------------------ 650| 0| } 651| | 652| | /* sanity check */ 653| 2.63k| if (fu_cbor_item_get_kind(item) != FU_CBOR_ITEM_KIND_MAP) { ------------------ | Branch (653:6): [True: 16, False: 2.62k] ------------------ 654| 16| g_set_error_literal(error, 655| 16| FWUPD_ERROR, ------------------ | | 15| 16|#define FWUPD_ERROR fwupd_error_quark() ------------------ 656| 16| FWUPD_ERROR_INVALID_DATA, 657| 16| "root item is not a map"); 658| 16| return FALSE; ------------------ | | 814| 16|#define FALSE (0) ------------------ 659| 16| } 660| | 661| | /* parse out anything interesting */ 662| 9.22k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (662:20): [True: 7.35k, False: 1.87k] ------------------ 663| 7.35k| FuCoswidTag tag_id = 0; 664| 7.35k| FuCborItem *item_key = NULL; 665| 7.35k| FuCborItem *item_value = NULL; 666| | 667| 7.35k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 668| 7.35k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (668:7): [True: 22, False: 7.33k] ------------------ 669| 22| g_prefix_error(error, "failed to parse root tag %u: ", (guint)i); 670| 22| return FALSE; ------------------ | | 814| 22|#define FALSE (0) ------------------ 671| 22| } 672| | 673| | /* identity can be specified as a string or in binary */ 674| 7.33k| if (tag_id == FU_COSWID_TAG_TAG_ID) { ------------------ | Branch (674:7): [True: 463, False: 6.86k] ------------------ 675| 463| g_autofree gchar *str = fu_coswid_read_string(item_value, error); ------------------ | | 1167| 463|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 463|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 676| 463| if (str == NULL) { ------------------ | Branch (676:8): [True: 83, False: 380] ------------------ 677| 83| g_prefix_error_literal(error, "failed to parse tag-id: "); ------------------ | | 11| 83|#define g_prefix_error_literal g_prefix_error ------------------ 678| 83| return FALSE; ------------------ | | 814| 83|#define FALSE (0) ------------------ 679| 83| } 680| 380| fu_firmware_set_id(firmware, str); 681| 6.86k| } else if (tag_id == FU_COSWID_TAG_SOFTWARE_NAME) { ------------------ | Branch (681:14): [True: 54, False: 6.81k] ------------------ 682| 54| g_free(priv->product); 683| 54| priv->product = fu_coswid_read_string(item_value, error); 684| 54| if (priv->product == NULL) { ------------------ | Branch (684:8): [True: 6, False: 48] ------------------ 685| 6| g_prefix_error_literal(error, "failed to parse product: "); ------------------ | | 11| 6|#define g_prefix_error_literal g_prefix_error ------------------ 686| 6| return FALSE; ------------------ | | 814| 6|#define FALSE (0) ------------------ 687| 6| } 688| 6.81k| } else if (tag_id == FU_COSWID_TAG_SOFTWARE_VERSION) { ------------------ | Branch (688:14): [True: 371, False: 6.44k] ------------------ 689| 371| g_autofree gchar *str = fu_coswid_read_string(item_value, error); ------------------ | | 1167| 371|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 371|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 690| 371| if (str == NULL) { ------------------ | Branch (690:8): [True: 10, False: 361] ------------------ 691| 10| g_prefix_error_literal(error, "failed to parse software-version: "); ------------------ | | 11| 10|#define g_prefix_error_literal g_prefix_error ------------------ 692| 10| return FALSE; ------------------ | | 814| 10|#define FALSE (0) ------------------ 693| 10| } 694| 361| fu_firmware_set_version(firmware, str); 695| 6.44k| } else if (tag_id == FU_COSWID_TAG_VERSION_SCHEME) { ------------------ | Branch (695:14): [True: 192, False: 6.25k] ------------------ 696| 192| if (!fu_coswid_read_version_scheme(item_value, ------------------ | Branch (696:8): [True: 1, False: 191] ------------------ 697| 192| &priv->version_scheme, 698| 192| error)) 699| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 700| 6.25k| } else if (tag_id == FU_COSWID_TAG_SOFTWARE_META) { ------------------ | Branch (700:14): [True: 224, False: 6.02k] ------------------ 701| 224| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (701:8): [True: 10, False: 214] ------------------ 702| 224| fu_coswid_firmware_parse_meta, 703| 224| self, /* user_data */ 704| 224| error)) 705| 10| return FALSE; ------------------ | | 814| 10|#define FALSE (0) ------------------ 706| 6.02k| } else if (tag_id == FU_COSWID_TAG_EVIDENCE) { ------------------ | Branch (706:14): [True: 240, False: 5.78k] ------------------ 707| 240| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (707:8): [True: 12, False: 228] ------------------ 708| 240| fu_coswid_firmware_parse_evidence, 709| 240| self, /* user_data */ 710| 240| error)) 711| 12| return FALSE; ------------------ | | 814| 12|#define FALSE (0) ------------------ 712| 5.78k| } else if (tag_id == FU_COSWID_TAG_LINK) { ------------------ | Branch (712:14): [True: 741, False: 5.04k] ------------------ 713| 741| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (713:8): [True: 18, False: 723] ------------------ 714| 741| fu_coswid_firmware_parse_link, 715| 741| self, /* user_data */ 716| 741| error)) 717| 18| return FALSE; ------------------ | | 814| 18|#define FALSE (0) ------------------ 718| 5.04k| } else if (tag_id == FU_COSWID_TAG_PAYLOAD) { ------------------ | Branch (718:14): [True: 1.09k, False: 3.95k] ------------------ 719| 1.09k| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (719:8): [True: 163, False: 931] ------------------ 720| 1.09k| fu_coswid_firmware_parse_payload, 721| 1.09k| self, /* user_data */ 722| 1.09k| error)) 723| 163| return FALSE; ------------------ | | 814| 163|#define FALSE (0) ------------------ 724| 3.95k| } else if (tag_id == FU_COSWID_TAG_ENTITY) { ------------------ | Branch (724:14): [True: 529, False: 3.42k] ------------------ 725| 529| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (725:8): [True: 421, False: 108] ------------------ 726| 529| fu_coswid_firmware_parse_entity, 727| 529| self, /* user_data */ 728| 529| error)) 729| 421| return FALSE; ------------------ | | 814| 421|#define FALSE (0) ------------------ 730| 3.42k| } else { 731| 3.42k| g_debug("unhandled tag %s from root", fu_coswid_tag_to_string(tag_id)); ------------------ | | 351| 3.42k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 3.42k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 3.42k| G_LOG_LEVEL_DEBUG, \ | | 353| 3.42k| __VA_ARGS__) ------------------ 732| 3.42k| } 733| 7.33k| } 734| | 735| | /* device not supported */ 736| 1.87k| if (fu_firmware_get_id(firmware) == NULL && fu_firmware_get_version(firmware) == NULL && ------------------ | Branch (736:6): [True: 1.67k, False: 197] | Branch (736:46): [True: 1.53k, False: 144] ------------------ 737| 1.53k| priv->product == NULL && priv->entities->len == 0 && priv->links->len == 0) { ------------------ | Branch (737:6): [True: 1.51k, False: 18] | Branch (737:31): [True: 1.49k, False: 22] | Branch (737:59): [True: 1.11k, False: 380] ------------------ 738| 1.11k| g_set_error_literal(error, 739| 1.11k| FWUPD_ERROR, ------------------ | | 15| 1.11k|#define FWUPD_ERROR fwupd_error_quark() ------------------ 740| 1.11k| FWUPD_ERROR_NOT_SUPPORTED, 741| 1.11k| "not enough SBOM data"); 742| 1.11k| return FALSE; ------------------ | | 814| 1.11k|#define FALSE (0) ------------------ 743| 1.11k| } 744| | 745| | /* success */ 746| 761| return TRUE; ------------------ | | 818| 761|#define TRUE (!FALSE) | | ------------------ | | | | 814| 761|#define FALSE (0) | | ------------------ ------------------ 747| 1.87k|} fu-coswid-firmware.c:fu_coswid_firmware_parse_meta: 119| 333|{ 120| 333| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 121| 333| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 333|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 122| | 123| 1.58k| for (guint i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (123:20): [True: 1.26k, False: 327] ------------------ 124| 1.26k| FuCoswidTag tag_id = 0; 125| 1.26k| FuCborItem *item_key = NULL; 126| 1.26k| FuCborItem *item_value = NULL; 127| | 128| 1.26k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 129| 1.26k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (129:7): [True: 3, False: 1.25k] ------------------ 130| 3| g_prefix_error(error, "failed to parse meta tag %u: ", (guint)i); 131| 3| return FALSE; ------------------ | | 814| 3|#define FALSE (0) ------------------ 132| 3| } 133| 1.25k| if (tag_id == FU_COSWID_TAG_SUMMARY) { ------------------ | Branch (133:7): [True: 113, False: 1.14k] ------------------ 134| 113| g_free(priv->summary); 135| 113| priv->summary = fu_coswid_read_string(item_value, error); 136| 113| if (priv->summary == NULL) { ------------------ | Branch (136:8): [True: 1, False: 112] ------------------ 137| 1| g_prefix_error_literal(error, "failed to parse summary: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 138| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 139| 1| } 140| 1.14k| } else if (tag_id == FU_COSWID_TAG_COLLOQUIAL_VERSION) { ------------------ | Branch (140:14): [True: 36, False: 1.10k] ------------------ 141| 36| g_free(priv->colloquial_version); 142| 36| priv->colloquial_version = fu_coswid_read_string(item_value, error); 143| 36| if (priv->colloquial_version == NULL) { ------------------ | Branch (143:8): [True: 1, False: 35] ------------------ 144| 1| g_prefix_error_literal(error, ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 145| 1| "failed to parse colloquial-version: "); 146| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 147| 1| } 148| 1.10k| } else if (tag_id == FU_COSWID_TAG_PERSISTENT_ID) { ------------------ | Branch (148:14): [True: 86, False: 1.02k] ------------------ 149| 86| g_free(priv->persistent_id); 150| 86| priv->persistent_id = fu_coswid_read_string(item_value, error); 151| 86| if (priv->persistent_id == NULL) { ------------------ | Branch (151:8): [True: 1, False: 85] ------------------ 152| 1| g_prefix_error_literal(error, "failed to parse persistent-id: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 153| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 154| 1| } 155| 1.02k| } else { 156| 1.02k| g_debug("unhandled tag %s from %s", ------------------ | | 351| 1.02k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 1.02k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 1.02k| G_LOG_LEVEL_DEBUG, \ | | 353| 1.02k| __VA_ARGS__) ------------------ 157| 1.02k| fu_coswid_tag_to_string(tag_id), 158| 1.02k| fu_coswid_tag_to_string(FU_COSWID_TAG_SOFTWARE_META)); 159| 1.02k| } 160| 1.25k| } 161| | 162| | /* success */ 163| 327| return TRUE; ------------------ | | 818| 327|#define TRUE (!FALSE) | | ------------------ | | | | 814| 327|#define FALSE (0) | | ------------------ ------------------ 164| 333|} fu-coswid-firmware.c:fu_coswid_firmware_parse_evidence: 169| 399|{ 170| 399| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 171| 399| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 399|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 172| | 173| 3.46k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (173:20): [True: 3.07k, False: 395] ------------------ 174| 3.07k| FuCoswidTag tag_id = 0; 175| 3.07k| FuCborItem *item_key = NULL; 176| 3.07k| FuCborItem *item_value = NULL; 177| | 178| 3.07k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 179| 3.07k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (179:7): [True: 3, False: 3.06k] ------------------ 180| 3| g_prefix_error(error, "failed to parse evidence tag %u: ", (guint)i); 181| 3| return FALSE; ------------------ | | 814| 3|#define FALSE (0) ------------------ 182| 3| } 183| 3.06k| if (tag_id == FU_COSWID_TAG_DEVICE_ID) { ------------------ | Branch (183:7): [True: 36, False: 3.03k] ------------------ 184| 36| g_free(priv->device_id); 185| 36| priv->device_id = fu_coswid_read_string(item_value, error); 186| 36| if (priv->device_id == NULL) { ------------------ | Branch (186:8): [True: 1, False: 35] ------------------ 187| 1| g_prefix_error_literal(error, "failed to parse device-id: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 188| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 189| 1| } 190| 3.03k| } else { 191| 3.03k| g_debug("unhandled tag %s from %s", ------------------ | | 351| 3.03k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 3.03k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 3.03k| G_LOG_LEVEL_DEBUG, \ | | 353| 3.03k| __VA_ARGS__) ------------------ 192| 3.03k| fu_coswid_tag_to_string(tag_id), 193| 3.03k| fu_coswid_tag_to_string(FU_COSWID_TAG_SOFTWARE_META)); 194| 3.03k| } 195| 3.06k| } 196| | 197| | /* success */ 198| 395| return TRUE; ------------------ | | 818| 395|#define TRUE (!FALSE) | | ------------------ | | | | 814| 395|#define FALSE (0) | | ------------------ ------------------ 199| 399|} fu-coswid-firmware.c:fu_coswid_firmware_parse_link: 204| 4.88k|{ 205| 4.88k| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 206| 4.88k| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 4.88k|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 207| 4.88k| g_autoptr(FuCoswidFirmwareLink) link = g_new0(FuCoswidFirmwareLink, 1); ------------------ | | 1162| 4.88k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 4.88k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ g_autoptr(FuCoswidFirmwareLink) link = g_new0(FuCoswidFirmwareLink, 1); ------------------ | | 307| 4.88k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 4.88k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 4.88k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 4.88k| gsize __n = (gsize) (n_structs); \ | | | | 237| 4.88k| gsize __s = sizeof (struct_type); \ | | | | 238| 4.88k| gpointer __p; \ | | | | 239| 4.88k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 4.88k] | | | | ------------------ | | | | 240| 4.88k| __p = g_##func (__n); \ | | | | 241| 4.88k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 4.88k, False: 0] | | | | ------------------ | | | | 242| 4.88k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 4.88k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 4.88k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 4.88k] | | | | | Branch (242:26): [True: 4.88k, False: 0] | | | | ------------------ | | | | 243| 4.88k| __p = g_##func (__n * __s); \ | | | | 244| 4.88k| else \ | | | | 245| 4.88k| __p = g_##func##_n (__n, __s); \ | | | | 246| 4.88k| __p; \ | | | | 247| 4.88k| })) | | ------------------ ------------------ 208| | 209| 6.69k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (209:20): [True: 1.82k, False: 4.87k] ------------------ 210| 1.82k| FuCoswidTag tag_id = 0; 211| 1.82k| FuCborItem *item_key = NULL; 212| 1.82k| FuCborItem *item_value = NULL; 213| | 214| 1.82k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 215| 1.82k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (215:7): [True: 4, False: 1.81k] ------------------ 216| 4| g_prefix_error(error, "failed to parse link tag %u: ", (guint)i); 217| 4| return FALSE; ------------------ | | 814| 4|#define FALSE (0) ------------------ 218| 4| } 219| 1.81k| if (tag_id == FU_COSWID_TAG_HREF) { ------------------ | Branch (219:7): [True: 152, False: 1.66k] ------------------ 220| 152| g_free(link->href); 221| 152| link->href = fu_coswid_read_string(item_value, error); 222| 152| if (link->href == NULL) { ------------------ | Branch (222:8): [True: 1, False: 151] ------------------ 223| 1| g_prefix_error_literal(error, "failed to parse link href: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 224| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 225| 1| } 226| 1.66k| } else if (tag_id == FU_COSWID_TAG_REL) { ------------------ | Branch (226:14): [True: 139, False: 1.52k] ------------------ 227| 139| gint64 tmp = 0; 228| 139| if (!fu_cbor_item_get_integer(item_value, &tmp, error)) { ------------------ | Branch (228:8): [True: 1, False: 138] ------------------ 229| 1| g_prefix_error_literal(error, "failed to parse link rel: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 230| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 231| 1| } 232| 138| link->rel = tmp; 233| 1.52k| } else { 234| 1.52k| g_debug("unhandled tag %s from %s", ------------------ | | 351| 1.52k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 1.52k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 1.52k| G_LOG_LEVEL_DEBUG, \ | | 353| 1.52k| __VA_ARGS__) ------------------ 235| 1.52k| fu_coswid_tag_to_string(tag_id), 236| 1.52k| fu_coswid_tag_to_string(FU_COSWID_TAG_LINK)); 237| 1.52k| } 238| 1.81k| } 239| | 240| | /* success */ 241| 4.87k| g_ptr_array_add(priv->links, g_steal_pointer(&link)); ------------------ | | 222| 4.87k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 242| 4.87k| return TRUE; ------------------ | | 818| 4.87k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 4.87k|#define FALSE (0) | | ------------------ ------------------ 243| 4.88k|} fu-coswid-firmware.c:fu_coswid_firmware_link_free: 80| 4.88k|{ 81| 4.88k| g_free(link->href); 82| 4.88k| g_free(link); 83| 4.88k|} fu-coswid-firmware.c:fu_coswid_firmware_parse_payload: 447| 1.26k|{ 448| 1.26k| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 449| 5.00k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (449:20): [True: 3.89k, False: 1.10k] ------------------ 450| 3.89k| FuCoswidTag tag_id = 0; 451| 3.89k| FuCborItem *item_key = NULL; 452| 3.89k| FuCborItem *item_value = NULL; 453| | 454| 3.89k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 455| 3.89k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (455:7): [True: 7, False: 3.88k] ------------------ 456| 7| g_prefix_error(error, "failed to parse payload tag %u: ", (guint)i); 457| 7| return FALSE; ------------------ | | 814| 7|#define FALSE (0) ------------------ 458| 7| } 459| 3.88k| if (tag_id == FU_COSWID_TAG_FILE) { ------------------ | Branch (459:7): [True: 729, False: 3.15k] ------------------ 460| 729| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (460:8): [True: 115, False: 614] ------------------ 461| 729| fu_coswid_firmware_parse_file, 462| 729| self, /* user_data */ 463| 729| error)) 464| 115| return FALSE; ------------------ | | 814| 115|#define FALSE (0) ------------------ 465| 3.15k| } else if (tag_id == FU_COSWID_TAG_DIRECTORY) { ------------------ | Branch (465:14): [True: 408, False: 2.74k] ------------------ 466| 408| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (466:8): [True: 30, False: 378] ------------------ 467| 408| fu_coswid_firmware_parse_directory, 468| 408| self, /* user_data */ 469| 408| error)) 470| 30| return FALSE; ------------------ | | 814| 30|#define FALSE (0) ------------------ 471| 2.74k| } else { 472| 2.74k| g_debug("unhandled tag %s from %s", ------------------ | | 351| 2.74k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 2.74k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 2.74k| G_LOG_LEVEL_DEBUG, \ | | 353| 2.74k| __VA_ARGS__) ------------------ 473| 2.74k| fu_coswid_tag_to_string(tag_id), 474| 2.74k| fu_coswid_tag_to_string(FU_COSWID_TAG_PAYLOAD)); 475| 2.74k| } 476| 3.88k| } 477| | 478| | /* success */ 479| 1.10k| return TRUE; ------------------ | | 818| 1.10k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1.10k|#define FALSE (0) | | ------------------ ------------------ 480| 1.26k|} fu-coswid-firmware.c:fu_coswid_firmware_parse_file: 310| 2.12k|{ 311| 2.12k| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 312| 2.12k| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 2.12k|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 313| 2.12k| g_autoptr(FuCoswidFirmwarePayload) payload = fu_coswid_firmware_payload_new(); ------------------ | | 1162| 2.12k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 2.12k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 314| | 315| 6.55k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (315:20): [True: 4.54k, False: 2.01k] ------------------ 316| 4.54k| FuCoswidTag tag_id = 0; 317| 4.54k| FuCborItem *item_key = NULL; 318| 4.54k| FuCborItem *item_value = NULL; 319| | 320| 4.54k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 321| 4.54k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (321:7): [True: 7, False: 4.53k] ------------------ 322| 7| g_prefix_error(error, "failed to parse file tag %u: ", (guint)i); 323| 7| return FALSE; ------------------ | | 814| 7|#define FALSE (0) ------------------ 324| 7| } 325| 4.53k| if (tag_id == FU_COSWID_TAG_FS_NAME) { ------------------ | Branch (325:7): [True: 85, False: 4.45k] ------------------ 326| 85| g_free(payload->name); 327| 85| payload->name = fu_coswid_read_string(item_value, error); 328| 85| if (payload->name == NULL) { ------------------ | Branch (328:8): [True: 1, False: 84] ------------------ 329| 1| g_prefix_error_literal(error, "failed to parse payload name: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 330| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 331| 1| } 332| 4.45k| } else if (tag_id == FU_COSWID_TAG_SIZE) { ------------------ | Branch (332:14): [True: 678, False: 3.77k] ------------------ 333| 678| gint64 tmp; 334| 678| if (!fu_cbor_item_get_integer(item_value, &tmp, error)) ------------------ | Branch (334:8): [True: 1, False: 677] ------------------ 335| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 336| 677| if (tmp < 0) { ------------------ | Branch (336:8): [True: 84, False: 593] ------------------ 337| 84| g_set_error_literal(error, 338| 84| FWUPD_ERROR, ------------------ | | 15| 84|#define FWUPD_ERROR fwupd_error_quark() ------------------ 339| 84| FWUPD_ERROR_INVALID_DATA, 340| 84| "payload size cannot be negative"); 341| 84| return FALSE; ------------------ | | 814| 84|#define FALSE (0) ------------------ 342| 84| } 343| 593| payload->size = (guint64)tmp; 344| 3.77k| } else if (tag_id == FU_COSWID_TAG_HASH) { ------------------ | Branch (344:14): [True: 415, False: 3.35k] ------------------ 345| 415| if (fu_cbor_item_get_kind(item_value) == FU_CBOR_ITEM_KIND_ARRAY && ------------------ | Branch (345:8): [True: 413, False: 2] ------------------ 346| 413| fu_cbor_item_array_length(item_value) >= 1) { ------------------ | Branch (346:8): [True: 412, False: 1] ------------------ 347| 412| FuCborItem *value = fu_cbor_item_array_index(item_value, 0); 348| | /* we can't use fu_coswid_parse_one_or_many() here as 349| | * the hash is an array, not a map -- for some reason */ 350| 412| if (fu_cbor_item_get_kind(value) == FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (350:9): [True: 165, False: 247] ------------------ 351| 165| if (!fu_coswid_firmware_parse_hash_array(item_value, ------------------ | Branch (351:10): [True: 13, False: 152] ------------------ 352| 165| payload, 353| 165| error)) 354| 13| return FALSE; ------------------ | | 814| 13|#define FALSE (0) ------------------ 355| 247| } else { 356| 247| if (!fu_coswid_firmware_parse_hash(item_value, ------------------ | Branch (356:10): [True: 3, False: 244] ------------------ 357| 247| payload, 358| 247| error)) 359| 3| return FALSE; ------------------ | | 814| 3|#define FALSE (0) ------------------ 360| 247| } 361| 412| } else { 362| 3| g_set_error_literal(error, 363| 3| FWUPD_ERROR, ------------------ | | 15| 3|#define FWUPD_ERROR fwupd_error_quark() ------------------ 364| 3| FWUPD_ERROR_INVALID_DATA, 365| 3| "hashes neither an array or array of array"); 366| 3| return FALSE; ------------------ | | 814| 3|#define FALSE (0) ------------------ 367| 3| } 368| 3.35k| } else { 369| 3.35k| g_debug("unhandled tag %s from %s", ------------------ | | 351| 3.35k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 3.35k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 3.35k| G_LOG_LEVEL_DEBUG, \ | | 353| 3.35k| __VA_ARGS__) ------------------ 370| 3.35k| fu_coswid_tag_to_string(tag_id), 371| 3.35k| fu_coswid_tag_to_string(FU_COSWID_TAG_FILE)); 372| 3.35k| } 373| 4.53k| } 374| | 375| | /* success */ 376| 2.01k| g_ptr_array_add(priv->payloads, g_steal_pointer(&payload)); ------------------ | | 222| 2.01k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 377| 2.01k| return TRUE; ------------------ | | 818| 2.01k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 2.01k|#define FALSE (0) | | ------------------ ------------------ 378| 2.12k|} fu-coswid-firmware.c:fu_coswid_firmware_payload_new: 99| 2.12k|{ 100| | FuCoswidFirmwarePayload *payload = g_new0(FuCoswidFirmwarePayload, 1); ------------------ | | 307| 2.12k|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2.12k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2.12k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2.12k| gsize __n = (gsize) (n_structs); \ | | | | 237| 2.12k| gsize __s = sizeof (struct_type); \ | | | | 238| 2.12k| gpointer __p; \ | | | | 239| 2.12k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2.12k] | | | | ------------------ | | | | 240| 2.12k| __p = g_##func (__n); \ | | | | 241| 2.12k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 2.12k, False: 0] | | | | ------------------ | | | | 242| 2.12k| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 2.12k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 2.12k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 2.12k] | | | | | Branch (242:26): [True: 2.12k, False: 0] | | | | ------------------ | | | | 243| 2.12k| __p = g_##func (__n * __s); \ | | | | 244| 2.12k| else \ | | | | 245| 2.12k| __p = g_##func##_n (__n, __s); \ | | | | 246| 2.12k| __p; \ | | | | 247| 2.12k| })) | | ------------------ ------------------ 101| 2.12k| payload->hashes = 102| 2.12k| g_ptr_array_new_with_free_func((GDestroyNotify)fu_coswid_firmware_hash_free); 103| 2.12k| return payload; 104| 2.12k|} fu-coswid-firmware.c:fu_coswid_firmware_hash_free: 89| 450|{ 90| 450| if (hash->value != NULL) ------------------ | Branch (90:6): [True: 434, False: 16] ------------------ 91| 434| g_bytes_unref(hash->value); 92| 450| g_free(hash); 93| 450|} fu-coswid-firmware.c:fu_coswid_firmware_payload_free: 108| 2.12k|{ 109| 2.12k| g_ptr_array_unref(payload->hashes); 110| 2.12k| g_free(payload->name); 111| 2.12k| g_free(payload); 112| 2.12k|} fu-coswid-firmware.c:fu_coswid_firmware_parse_hash_array: 298| 165|{ 299| 355| for (guint j = 0; j < fu_cbor_item_array_length(item); j++) { ------------------ | Branch (299:20): [True: 203, False: 152] ------------------ 300| 203| FuCborItem *value = fu_cbor_item_array_index(item, j); 301| 203| if (!fu_coswid_firmware_parse_hash(value, user_data, error)) ------------------ | Branch (301:7): [True: 13, False: 190] ------------------ 302| 13| return FALSE; ------------------ | | 814| 13|#define FALSE (0) ------------------ 303| 203| } 304| 152| return TRUE; ------------------ | | 818| 152|#define TRUE (!FALSE) | | ------------------ | | | | 814| 152|#define FALSE (0) | | ------------------ ------------------ 305| 165|} fu-coswid-firmware.c:fu_coswid_firmware_parse_hash: 248| 450|{ 249| 450| FuCoswidFirmwarePayload *payload = (FuCoswidFirmwarePayload *)user_data; 250| 450| gint64 alg_id8 = 0; 251| 450| g_autoptr(FuCoswidFirmwareHash) hash = g_new0(FuCoswidFirmwareHash, 1); ------------------ | | 1162| 450|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 450|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ g_autoptr(FuCoswidFirmwareHash) hash = g_new0(FuCoswidFirmwareHash, 1); ------------------ | | 307| 450|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 450| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 450|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 450| gsize __n = (gsize) (n_structs); \ | | | | 237| 450| gsize __s = sizeof (struct_type); \ | | | | 238| 450| gpointer __p; \ | | | | 239| 450| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 450] | | | | ------------------ | | | | 240| 450| __p = g_##func (__n); \ | | | | 241| 450| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 450, False: 0] | | | | ------------------ | | | | 242| 450| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 450|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 450|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 450] | | | | | Branch (242:26): [True: 450, False: 0] | | | | ------------------ | | | | 243| 450| __p = g_##func (__n * __s); \ | | | | 244| 450| else \ | | | | 245| 450| __p = g_##func##_n (__n, __s); \ | | | | 246| 450| __p; \ | | | | 247| 450| })) | | ------------------ ------------------ 252| 450| FuCborItem *hash_item_alg_id; 253| 450| FuCborItem *hash_item_value; 254| | 255| | /* sanity check */ 256| 450| if (fu_cbor_item_get_kind(item) != FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (256:6): [True: 6, False: 444] ------------------ 257| 6| g_set_error_literal(error, 258| 6| FWUPD_ERROR, ------------------ | | 15| 6|#define FWUPD_ERROR fwupd_error_quark() ------------------ 259| 6| FWUPD_ERROR_INVALID_DATA, 260| 6| "hash item is not an array"); 261| 6| return FALSE; ------------------ | | 814| 6|#define FALSE (0) ------------------ 262| 6| } 263| 444| if (fu_cbor_item_array_length(item) != 2) { ------------------ | Branch (263:6): [True: 5, False: 439] ------------------ 264| 5| g_set_error_literal(error, 265| 5| FWUPD_ERROR, ------------------ | | 15| 5|#define FWUPD_ERROR fwupd_error_quark() ------------------ 266| 5| FWUPD_ERROR_INVALID_DATA, 267| 5| "hash array has invalid size"); 268| 5| return FALSE; ------------------ | | 814| 5|#define FALSE (0) ------------------ 269| 5| } 270| 439| hash_item_alg_id = fu_cbor_item_array_index(item, 0); 271| 439| hash_item_value = fu_cbor_item_array_index(item, 1); 272| 439| if (hash_item_alg_id == NULL || hash_item_value == NULL) { ------------------ | Branch (272:6): [True: 0, False: 439] | Branch (272:34): [True: 0, False: 439] ------------------ 273| 0| g_set_error_literal(error, 274| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 275| 0| FWUPD_ERROR_INVALID_DATA, 276| 0| "invalid hash item"); 277| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 278| 0| } 279| 439| if (!fu_cbor_item_get_integer(hash_item_alg_id, &alg_id8, error)) { ------------------ | Branch (279:6): [True: 1, False: 438] ------------------ 280| 1| g_prefix_error_literal(error, "failed to parse hash alg-id: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 281| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 282| 1| } 283| | 284| | /* success */ 285| 438| hash->alg_id = alg_id8; 286| 438| hash->value = fu_cbor_item_get_bytes(hash_item_value, error); 287| 438| if (hash->value == NULL) { ------------------ | Branch (287:6): [True: 4, False: 434] ------------------ 288| 4| g_prefix_error_literal(error, "failed to parse hash value: "); ------------------ | | 11| 4|#define g_prefix_error_literal g_prefix_error ------------------ 289| 4| return FALSE; ------------------ | | 814| 4|#define FALSE (0) ------------------ 290| 4| } 291| 434| g_ptr_array_add(payload->hashes, g_steal_pointer(&hash)); ------------------ | | 222| 434|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 292| 434| return TRUE; ------------------ | | 818| 434|#define TRUE (!FALSE) | | ------------------ | | | | 814| 434|#define FALSE (0) | | ------------------ ------------------ 293| 438|} fu-coswid-firmware.c:fu_coswid_firmware_parse_directory: 415| 584|{ 416| 584| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 417| 4.63k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (417:20): [True: 4.06k, False: 562] ------------------ 418| 4.06k| FuCoswidTag tag_id = 0; 419| 4.06k| FuCborItem *item_key = NULL; 420| 4.06k| FuCborItem *item_value = NULL; 421| | 422| 4.06k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 423| 4.06k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (423:7): [True: 3, False: 4.06k] ------------------ 424| 3| g_prefix_error(error, "failed to parse directory tag %u: ", (guint)i); 425| 3| return FALSE; ------------------ | | 814| 3|#define FALSE (0) ------------------ 426| 3| } 427| 4.06k| if (tag_id == FU_COSWID_TAG_PATH_ELEMENTS) { ------------------ | Branch (427:7): [True: 406, False: 3.65k] ------------------ 428| 406| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (428:8): [True: 19, False: 387] ------------------ 429| 406| fu_coswid_firmware_parse_path_elements, 430| 406| self, /* user_data */ 431| 406| error)) 432| 19| return FALSE; ------------------ | | 814| 19|#define FALSE (0) ------------------ 433| 3.65k| } else { 434| 3.65k| g_debug("unhandled tag %s from %s", ------------------ | | 351| 3.65k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 3.65k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 3.65k| G_LOG_LEVEL_DEBUG, \ | | 353| 3.65k| __VA_ARGS__) ------------------ 435| 3.65k| fu_coswid_tag_to_string(tag_id), 436| 3.65k| fu_coswid_tag_to_string(FU_COSWID_TAG_DIRECTORY)); 437| 3.65k| } 438| 4.06k| } 439| | 440| | /* success */ 441| 562| return TRUE; ------------------ | | 818| 562|#define TRUE (!FALSE) | | ------------------ | | | | 814| 562|#define FALSE (0) | | ------------------ ------------------ 442| 584|} fu-coswid-firmware.c:fu_coswid_firmware_parse_path_elements: 383| 884|{ 384| 884| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 385| 6.34k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (385:20): [True: 5.47k, False: 874] ------------------ 386| 5.47k| FuCoswidTag tag_id = 0; 387| 5.47k| FuCborItem *item_key = NULL; 388| 5.47k| FuCborItem *item_value = NULL; 389| | 390| 5.47k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 391| 5.47k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (391:7): [True: 5, False: 5.46k] ------------------ 392| 5| g_prefix_error(error, "failed to parse elements tag %u: ", (guint)i); 393| 5| return FALSE; ------------------ | | 814| 5|#define FALSE (0) ------------------ 394| 5| } 395| 5.46k| if (tag_id == FU_COSWID_TAG_FILE) { ------------------ | Branch (395:7): [True: 557, False: 4.91k] ------------------ 396| 557| if (!fu_coswid_parse_one_or_many(item_value, ------------------ | Branch (396:8): [True: 5, False: 552] ------------------ 397| 557| fu_coswid_firmware_parse_file, 398| 557| self, /* user_data */ 399| 557| error)) 400| 5| return FALSE; ------------------ | | 814| 5|#define FALSE (0) ------------------ 401| 4.91k| } else { 402| 4.91k| g_debug("unhandled tag %s from %s", ------------------ | | 351| 4.91k|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 4.91k|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 4.91k| G_LOG_LEVEL_DEBUG, \ | | 353| 4.91k| __VA_ARGS__) ------------------ 403| 4.91k| fu_coswid_tag_to_string(tag_id), 404| 4.91k| fu_coswid_tag_to_string(FU_COSWID_TAG_PATH_ELEMENTS)); 405| 4.91k| } 406| 5.46k| } 407| | 408| | /* success */ 409| 874| return TRUE; ------------------ | | 818| 874|#define TRUE (!FALSE) | | ------------------ | | | | 814| 874|#define FALSE (0) | | ------------------ ------------------ 410| 884|} fu-coswid-firmware.c:fu_coswid_firmware_parse_entity: 573| 499|{ 574| 499| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(user_data); 575| 499| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 499|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 576| 499| g_autoptr(FuCoswidFirmwareEntity) entity = g_new0(FuCoswidFirmwareEntity, 1); ------------------ | | 1162| 499|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 499|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ g_autoptr(FuCoswidFirmwareEntity) entity = g_new0(FuCoswidFirmwareEntity, 1); ------------------ | | 307| 499|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 499| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 499|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 499| gsize __n = (gsize) (n_structs); \ | | | | 237| 499| gsize __s = sizeof (struct_type); \ | | | | 238| 499| gpointer __p; \ | | | | 239| 499| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 499] | | | | ------------------ | | | | 240| 499| __p = g_##func (__n); \ | | | | 241| 499| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 499, False: 0] | | | | ------------------ | | | | 242| 499| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 499|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 499|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 499] | | | | | Branch (242:26): [True: 499, False: 0] | | | | ------------------ | | | | 243| 499| __p = g_##func (__n * __s); \ | | | | 244| 499| else \ | | | | 245| 499| __p = g_##func##_n (__n, __s); \ | | | | 246| 499| __p; \ | | | | 247| 499| })) | | ------------------ ------------------ 577| | 578| 1.66k| for (gsize i = 0; i < fu_cbor_item_map_length(item); i++) { ------------------ | Branch (578:20): [True: 1.45k, False: 218] ------------------ 579| 1.45k| FuCoswidTag tag_id = 0; 580| 1.45k| FuCborItem *item_key = NULL; 581| 1.45k| FuCborItem *item_value = NULL; 582| | 583| 1.45k| fu_cbor_item_map_index(item, i, &item_key, &item_value); 584| 1.45k| if (!fu_coswid_read_tag(item_key, &tag_id, error)) { ------------------ | Branch (584:7): [True: 4, False: 1.44k] ------------------ 585| 4| g_prefix_error(error, "failed to parse entity tag %u: ", (guint)i); 586| 4| return FALSE; ------------------ | | 814| 4|#define FALSE (0) ------------------ 587| 4| } 588| 1.44k| if (tag_id == FU_COSWID_TAG_ENTITY_NAME) { ------------------ | Branch (588:7): [True: 97, False: 1.34k] ------------------ 589| 97| if (!fu_coswid_firmware_parse_entity_name(entity, item_value, error)) ------------------ | Branch (589:8): [True: 1, False: 96] ------------------ 590| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 591| 1.34k| } else if (tag_id == FU_COSWID_TAG_REG_ID) { ------------------ | Branch (591:14): [True: 45, False: 1.30k] ------------------ 592| 45| if (!fu_coswid_firmware_parse_entity_regid(entity, item_value, error)) ------------------ | Branch (592:8): [True: 1, False: 44] ------------------ 593| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 594| 1.30k| } else if (tag_id == FU_COSWID_TAG_ROLE) { ------------------ | Branch (594:14): [True: 422, False: 882] ------------------ 595| 422| if (!fu_coswid_firmware_parse_entity_role(entity, item_value, error)) ------------------ | Branch (595:8): [True: 275, False: 147] ------------------ 596| 275| return FALSE; ------------------ | | 814| 275|#define FALSE (0) ------------------ 597| 882| } else { 598| 882| g_debug("unhandled tag %s from %s", ------------------ | | 351| 882|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 882|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 352| 882| G_LOG_LEVEL_DEBUG, \ | | 353| 882| __VA_ARGS__) ------------------ 599| 882| fu_coswid_tag_to_string(tag_id), 600| 882| fu_coswid_tag_to_string(FU_COSWID_TAG_ENTITY)); 601| 882| } 602| 1.44k| } 603| | 604| | /* sanity check */ 605| 218| if (entity->name == NULL) { ------------------ | Branch (605:6): [True: 131, False: 87] ------------------ 606| 131| g_set_error_literal(error, 607| 131| FWUPD_ERROR, ------------------ | | 15| 131|#define FWUPD_ERROR fwupd_error_quark() ------------------ 608| 131| FWUPD_ERROR_INVALID_DATA, 609| 131| "entity does not have a name"); 610| 131| return FALSE; ------------------ | | 814| 131|#define FALSE (0) ------------------ 611| 131| } 612| 87| if (entity->roles == 0) { ------------------ | Branch (612:6): [True: 4, False: 83] ------------------ 613| 4| g_set_error_literal(error, 614| 4| FWUPD_ERROR, ------------------ | | 15| 4|#define FWUPD_ERROR fwupd_error_quark() ------------------ 615| 4| FWUPD_ERROR_INVALID_DATA, 616| 4| "entity has no roles"); 617| 4| return FALSE; ------------------ | | 814| 4|#define FALSE (0) ------------------ 618| 4| } 619| | 620| | /* success */ 621| 83| g_ptr_array_add(priv->entities, g_steal_pointer(&entity)); ------------------ | | 222| 83|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 622| 83| return TRUE; ------------------ | | 818| 83|#define TRUE (!FALSE) | | ------------------ | | | | 814| 83|#define FALSE (0) | | ------------------ ------------------ 623| 87|} fu-coswid-firmware.c:fu_coswid_firmware_entity_free: 70| 499|{ 71| 499| g_free(entity->name); 72| 499| g_free(entity->regid); 73| 499| g_free(entity); 74| 499|} fu-coswid-firmware.c:fu_coswid_firmware_parse_entity_name: 486| 97|{ 487| | /* we might be calling this twice... */ 488| 97| g_free(entity->name); 489| | 490| 97| entity->name = fu_coswid_read_string(item, error); 491| 97| if (entity->name == NULL) { ------------------ | Branch (491:6): [True: 1, False: 96] ------------------ 492| 1| g_prefix_error_literal(error, "failed to parse entity name: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 493| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 494| 1| } 495| | 496| | /* success */ 497| 96| return TRUE; ------------------ | | 818| 96|#define TRUE (!FALSE) | | ------------------ | | | | 814| 96|#define FALSE (0) | | ------------------ ------------------ 498| 97|} fu-coswid-firmware.c:fu_coswid_firmware_parse_entity_regid: 504| 45|{ 505| | /* we might be calling this twice... */ 506| 45| g_free(entity->regid); 507| | 508| 45| entity->regid = fu_coswid_read_string(item, error); 509| 45| if (entity->regid == NULL) { ------------------ | Branch (509:6): [True: 1, False: 44] ------------------ 510| 1| g_prefix_error_literal(error, "failed to parse entity regid: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 511| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 512| 1| } 513| | 514| | /* success */ 515| 44| return TRUE; ------------------ | | 818| 44|#define TRUE (!FALSE) | | ------------------ | | | | 814| 44|#define FALSE (0) | | ------------------ ------------------ 516| 45|} fu-coswid-firmware.c:fu_coswid_firmware_parse_entity_role: 522| 422|{ 523| 422| if (fu_cbor_item_get_kind(item) == FU_CBOR_ITEM_KIND_INTEGER) { ------------------ | Branch (523:6): [True: 206, False: 216] ------------------ 524| 206| gint64 tmp = 0; 525| 206| if (!fu_cbor_item_get_integer(item, &tmp, error)) { ------------------ | Branch (525:7): [True: 0, False: 206] ------------------ 526| 0| g_prefix_error_literal(error, "failed to parse entity role: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 527| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 528| 0| } 529| 206| if (tmp <= FU_COSWID_ENTITY_ROLE_UNKNOWN || tmp >= FU_COSWID_ENTITY_ROLE_LAST) { ------------------ | | 378| 145|#define FU_COSWID_ENTITY_ROLE_LAST 7 ------------------ | Branch (529:7): [True: 61, False: 145] | Branch (529:47): [True: 61, False: 84] ------------------ 530| 122| g_set_error(error, 531| 122| FWUPD_ERROR, ------------------ | | 15| 122|#define FWUPD_ERROR fwupd_error_quark() ------------------ 532| 122| FWUPD_ERROR_INVALID_DATA, 533| 122| "invalid entity role 0x%x", 534| 122| (guint)tmp); 535| 122| return FALSE; ------------------ | | 814| 122|#define FALSE (0) ------------------ 536| 122| } 537| 84| FU_BIT_SET(entity->roles, tmp); ------------------ | | 24| 84|#define FU_BIT_SET(val, pos) (val |= (1ull << (pos))) /* nocheck:blocked */ ------------------ 538| | 539| 216| } else if (fu_cbor_item_get_kind(item) == FU_CBOR_ITEM_KIND_ARRAY) { ------------------ | Branch (539:13): [True: 214, False: 2] ------------------ 540| 476| for (guint j = 0; j < fu_cbor_item_array_length(item); j++) { ------------------ | Branch (540:21): [True: 413, False: 63] ------------------ 541| 413| gint64 tmp = 0; 542| 413| FuCborItem *value = fu_cbor_item_array_index(item, j); 543| 413| if (!fu_cbor_item_get_integer(value, &tmp, error)) { ------------------ | Branch (543:8): [True: 1, False: 412] ------------------ 544| 1| g_prefix_error_literal(error, "failed to parse entity role: "); ------------------ | | 11| 1|#define g_prefix_error_literal g_prefix_error ------------------ 545| 1| return FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 546| 1| } 547| 412| if (tmp <= FU_COSWID_ENTITY_ROLE_UNKNOWN || ------------------ | Branch (547:8): [True: 81, False: 331] ------------------ 548| 331| tmp >= FU_COSWID_ENTITY_ROLE_LAST) { ------------------ | | 378| 331|#define FU_COSWID_ENTITY_ROLE_LAST 7 ------------------ | Branch (548:8): [True: 69, False: 262] ------------------ 549| 150| g_set_error(error, 550| 150| FWUPD_ERROR, ------------------ | | 15| 150|#define FWUPD_ERROR fwupd_error_quark() ------------------ 551| 150| FWUPD_ERROR_INVALID_DATA, 552| 150| "invalid entity role 0x%x", 553| 150| (guint)tmp); 554| 150| return FALSE; ------------------ | | 814| 150|#define FALSE (0) ------------------ 555| 150| } 556| 262| FU_BIT_SET(entity->roles, tmp); ------------------ | | 24| 262|#define FU_BIT_SET(val, pos) (val |= (1ull << (pos))) /* nocheck:blocked */ ------------------ 557| 262| } 558| 214| } else { 559| 2| g_set_error_literal(error, 560| 2| FWUPD_ERROR, ------------------ | | 15| 2|#define FWUPD_ERROR fwupd_error_quark() ------------------ 561| 2| FWUPD_ERROR_INVALID_DATA, 562| 2| "entity role item is not an uint or array"); 563| 2| return FALSE; ------------------ | | 814| 2|#define FALSE (0) ------------------ 564| 2| } 565| | 566| | /* success */ 567| 147| return TRUE; ------------------ | | 818| 147|#define TRUE (!FALSE) | | ------------------ | | | | 814| 147|#define FALSE (0) | | ------------------ ------------------ 568| 422|} fu-coswid-firmware.c:fu_coswid_firmware_write: 921| 761|{ 922| 761| FuCoswidFirmware *self = FU_COSWID_FIRMWARE(firmware); 923| 761| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 761|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 924| 761| g_autoptr(FuCborItem) root = fu_cbor_item_new_map(); ------------------ | | 1162| 761|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 761|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 925| 761| g_autoptr(FuCborItem) item_meta = fu_cbor_item_new_map(); ------------------ | | 1162| 761|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 761|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 926| | 927| | /* preallocate the map structure */ 928| 761| fu_coswid_write_tag_string(root, FU_COSWID_TAG_LANG, "en-US"); 929| 761| if (fu_firmware_get_id(firmware) != NULL) { ------------------ | Branch (929:6): [True: 197, False: 564] ------------------ 930| 197| fwupd_guid_t uuid = {0}; 931| 197| if (fwupd_guid_from_string(fu_firmware_get_id(firmware), ------------------ | Branch (931:7): [True: 46, False: 151] ------------------ 932| 197| &uuid, 933| 197| FWUPD_GUID_FLAG_NONE, 934| 197| NULL)) { 935| 46| fu_coswid_write_tag_bytestring(root, 936| 46| FU_COSWID_TAG_TAG_ID, 937| 46| (const guint8 *)&uuid, 938| 46| sizeof(uuid)); 939| 151| } else { 940| 151| fu_coswid_write_tag_string(root, 941| 151| FU_COSWID_TAG_TAG_ID, 942| 151| fu_firmware_get_id(firmware)); 943| 151| } 944| 197| } 945| 761| fu_coswid_write_tag_bool(root, FU_COSWID_TAG_CORPUS, TRUE); ------------------ | | 818| 761|#define TRUE (!FALSE) | | ------------------ | | | | 814| 761|#define FALSE (0) | | ------------------ ------------------ 946| 761| if (priv->product != NULL) ------------------ | Branch (946:6): [True: 21, False: 740] ------------------ 947| 21| fu_coswid_write_tag_string(root, FU_COSWID_TAG_SOFTWARE_NAME, priv->product); 948| 761| if (fu_firmware_get_version(firmware) != NULL) { ------------------ | Branch (948:6): [True: 147, False: 614] ------------------ 949| 147| fu_coswid_write_tag_string(root, 950| 147| FU_COSWID_TAG_SOFTWARE_VERSION, 951| 147| fu_firmware_get_version(firmware)); 952| 147| } 953| 761| if (priv->version_scheme != FU_COSWID_VERSION_SCHEME_UNKNOWN) ------------------ | Branch (953:6): [True: 757, False: 4] ------------------ 954| 757| fu_coswid_write_tag_integer(root, 955| 757| FU_COSWID_TAG_VERSION_SCHEME, 956| 757| priv->version_scheme); 957| 761| fu_coswid_write_tag_item(root, FU_COSWID_TAG_SOFTWARE_META, item_meta); 958| 761| fu_coswid_write_tag_string(item_meta, FU_COSWID_TAG_GENERATOR, PACKAGE_NAME); ------------------ | | 10| 761|#define PACKAGE_NAME "fwupd" ------------------ 959| 761| if (priv->summary != NULL) ------------------ | Branch (959:6): [True: 1, False: 760] ------------------ 960| 1| fu_coswid_write_tag_string(item_meta, FU_COSWID_TAG_SUMMARY, priv->summary); 961| 761| if (priv->colloquial_version != NULL) { ------------------ | Branch (961:6): [True: 1, False: 760] ------------------ 962| 1| fu_coswid_write_tag_string(item_meta, 963| 1| FU_COSWID_TAG_COLLOQUIAL_VERSION, 964| 1| priv->colloquial_version); 965| 1| } 966| 761| if (priv->persistent_id != NULL) { ------------------ | Branch (966:6): [True: 1, False: 760] ------------------ 967| 1| fu_coswid_write_tag_string(item_meta, 968| 1| FU_COSWID_TAG_PERSISTENT_ID, 969| 1| priv->persistent_id); 970| 1| } 971| | 972| | /* add evidence */ 973| 761| if (priv->device_id != NULL) { ------------------ | Branch (973:6): [True: 1, False: 760] ------------------ 974| 1| g_autoptr(FuCborItem) items = fu_cbor_item_new_array(); ------------------ | | 1162| 1|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 1|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 975| 1| if (!fu_coswid_firmware_write_evidence(items, priv->device_id, error)) ------------------ | Branch (975:7): [True: 0, False: 1] ------------------ 976| 0| return NULL; 977| 1| fu_coswid_write_tag_item(root, FU_COSWID_TAG_EVIDENCE, items); 978| 1| } 979| | 980| | /* add entities */ 981| 761| if (priv->entities->len > 0) { ------------------ | Branch (981:6): [True: 22, False: 739] ------------------ 982| 22| g_autoptr(FuCborItem) item_entities = fu_cbor_item_new_array(); ------------------ | | 1162| 22|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 22|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 983| 95| for (guint i = 0; i < priv->entities->len; i++) { ------------------ | Branch (983:21): [True: 73, False: 22] ------------------ 984| 73| FuCoswidFirmwareEntity *entity = g_ptr_array_index(priv->entities, i); ------------------ | | 138| 73|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 985| 73| if (!fu_coswid_firmware_write_entity(item_entities, entity, error)) ------------------ | Branch (985:8): [True: 0, False: 73] ------------------ 986| 0| return NULL; 987| 73| } 988| 22| fu_coswid_write_tag_item(root, FU_COSWID_TAG_ENTITY, item_entities); 989| 22| } 990| | 991| | /* add links */ 992| 761| if (priv->links->len > 0) { ------------------ | Branch (992:6): [True: 383, False: 378] ------------------ 993| 383| g_autoptr(FuCborItem) item_links = fu_cbor_item_new_array(); ------------------ | | 1162| 383|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 383|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 994| 4.66k| for (guint i = 0; i < priv->links->len; i++) { ------------------ | Branch (994:21): [True: 4.28k, False: 383] ------------------ 995| 4.28k| FuCoswidFirmwareLink *link = g_ptr_array_index(priv->links, i); ------------------ | | 138| 4.28k|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 996| 4.28k| g_autoptr(FuCborItem) item_link = fu_cbor_item_new_map(); ------------------ | | 1162| 4.28k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 4.28k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 997| 4.28k| if (link->href != NULL) { ------------------ | Branch (997:8): [True: 61, False: 4.22k] ------------------ 998| 61| fu_coswid_write_tag_string(item_link, 999| 61| FU_COSWID_TAG_HREF, 1000| 61| link->href); 1001| 61| } 1002| 4.28k| fu_coswid_write_tag_integer(item_link, FU_COSWID_TAG_REL, link->rel); 1003| 4.28k| if (!fu_cbor_item_array_append(item_links, item_link, error)) ------------------ | Branch (1003:8): [True: 0, False: 4.28k] ------------------ 1004| 0| return NULL; 1005| 4.28k| } 1006| 383| fu_coswid_write_tag_item(root, FU_COSWID_TAG_LINK, item_links); 1007| 383| } 1008| | 1009| | /* add payloads */ 1010| 761| if (priv->payloads->len > 0) { ------------------ | Branch (1010:6): [True: 123, False: 638] ------------------ 1011| 123| g_autoptr(FuCborItem) item_payloads = fu_cbor_item_new_array(); ------------------ | | 1162| 123|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 123|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1012| 788| for (guint i = 0; i < priv->payloads->len; i++) { ------------------ | Branch (1012:21): [True: 665, False: 123] ------------------ 1013| 665| FuCoswidFirmwarePayload *payload = g_ptr_array_index(priv->payloads, i); ------------------ | | 138| 665|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 1014| 665| if (!fu_coswid_firmware_write_payload(item_payloads, payload, error)) ------------------ | Branch (1014:8): [True: 0, False: 665] ------------------ 1015| 0| return NULL; 1016| 665| } 1017| 123| fu_coswid_write_tag_item(root, FU_COSWID_TAG_PAYLOAD, item_payloads); 1018| 123| } 1019| | 1020| | /* serialize */ 1021| 761| return fu_cbor_item_write(root, error); 1022| 761|} fu-coswid-firmware.c:fu_coswid_firmware_write_evidence: 913| 1|{ 914| 1| g_autoptr(FuCborItem) item_entity = fu_cbor_item_new_map(); ------------------ | | 1162| 1|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 1|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 915| 1| fu_coswid_write_tag_string(item_entity, FU_COSWID_TAG_DEVICE_ID, device_id); 916| 1| return fu_cbor_item_array_append(root, item_entity, error); 917| 1|} fu-coswid-firmware.c:fu_coswid_firmware_write_entity: 893| 73|{ 894| 73| g_autoptr(FuCborItem) item_entity = fu_cbor_item_new_map(); ------------------ | | 1162| 73|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 73|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 895| 73| g_autoptr(FuCborItem) item_roles = fu_cbor_item_new_array(); ------------------ | | 1162| 73|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 73|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 896| 73| if (entity->name != NULL) ------------------ | Branch (896:6): [True: 73, False: 0] ------------------ 897| 73| fu_coswid_write_tag_string(item_entity, FU_COSWID_TAG_ENTITY_NAME, entity->name); 898| 73| if (entity->regid != NULL) ------------------ | Branch (898:6): [True: 10, False: 63] ------------------ 899| 10| fu_coswid_write_tag_string(item_entity, FU_COSWID_TAG_REG_ID, entity->regid); 900| 584| for (guint j = 0; j < FU_COSWID_ENTITY_ROLE_LAST; j++) { ------------------ | | 378| 584|#define FU_COSWID_ENTITY_ROLE_LAST 7 ------------------ | Branch (900:20): [True: 511, False: 73] ------------------ 901| 511| if (FU_BIT_IS_SET(entity->roles, j)) { ------------------ | | 48| 511|#define FU_BIT_IS_SET(val, pos) (val & (1ull << (pos))) | | ------------------ | | | Branch (48:33): [True: 113, False: 398] | | ------------------ ------------------ 902| 113| g_autoptr(FuCborItem) item_role = fu_cbor_item_new_integer(j); ------------------ | | 1162| 113|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 113|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 903| 113| if (!fu_cbor_item_array_append(item_roles, item_role, error)) ------------------ | Branch (903:8): [True: 0, False: 113] ------------------ 904| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 905| 113| } 906| 511| } 907| 73| fu_coswid_write_tag_item(item_entity, FU_COSWID_TAG_ROLE, item_roles); 908| 73| return fu_cbor_item_array_append(root, item_entity, error); 909| 73|} fu-coswid-firmware.c:fu_coswid_firmware_write_payload: 869| 665|{ 870| 665| g_autoptr(FuCborItem) item_payload = fu_cbor_item_new_map(); ------------------ | | 1162| 665|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 665|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 871| 665| g_autoptr(FuCborItem) item_file = fu_cbor_item_new_map(); ------------------ | | 1162| 665|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 665|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 872| 665| if (payload->name != NULL) ------------------ | Branch (872:6): [True: 18, False: 647] ------------------ 873| 18| fu_coswid_write_tag_string(item_file, FU_COSWID_TAG_FS_NAME, payload->name); 874| 665| if (payload->size != 0) ------------------ | Branch (874:6): [True: 149, False: 516] ------------------ 875| 149| fu_coswid_write_tag_integer(item_file, FU_COSWID_TAG_SIZE, payload->size); 876| 665| if (payload->hashes->len > 0) { ------------------ | Branch (876:6): [True: 97, False: 568] ------------------ 877| 97| g_autoptr(FuCborItem) item_hashes = fu_cbor_item_new_array(); ------------------ | | 1162| 97|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 97|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 878| 364| for (guint j = 0; j < payload->hashes->len; j++) { ------------------ | Branch (878:21): [True: 267, False: 97] ------------------ 879| 267| FuCoswidFirmwareHash *hash = g_ptr_array_index(payload->hashes, j); ------------------ | | 138| 267|#define g_ptr_array_index(array,index_) ((array)->pdata)[index_] ------------------ 880| 267| if (!fu_coswid_firmware_write_hash(item_hashes, hash, error)) { ------------------ | Branch (880:8): [True: 0, False: 267] ------------------ 881| 0| g_prefix_error_literal(error, "failed to add payload: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 882| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 883| 0| } 884| 267| } 885| 97| fu_coswid_write_tag_item(item_file, FU_COSWID_TAG_HASH, item_hashes); 886| 97| } 887| 665| fu_coswid_write_tag_item(item_payload, FU_COSWID_TAG_FILE, item_file); 888| 665| return fu_cbor_item_array_append(root, item_payload, error); 889| 665|} fu-coswid-firmware.c:fu_coswid_firmware_write_hash: 852| 267|{ 853| 267| g_autoptr(FuCborItem) item_hash = fu_cbor_item_new_array(); ------------------ | | 1162| 267|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 267|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 854| 267| g_autoptr(FuCborItem) item_hash_alg_id = fu_cbor_item_new_integer(hash->alg_id); ------------------ | | 1162| 267|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 267|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 855| 267| g_autoptr(FuCborItem) item_hash_value = fu_cbor_item_new_bytes(hash->value); ------------------ | | 1162| 267|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 267|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 856| 267| if (!fu_cbor_item_array_append(item_hash, item_hash_alg_id, error)) ------------------ | Branch (856:6): [True: 0, False: 267] ------------------ 857| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 858| 267| if (!fu_cbor_item_array_append(item_hash, item_hash_value, error)) ------------------ | Branch (858:6): [True: 0, False: 267] ------------------ 859| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 860| 267| if (!fu_cbor_item_array_append(root, item_hash, error)) ------------------ | Branch (860:6): [True: 0, False: 267] ------------------ 861| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 862| | 863| | /* success */ 864| 267| return TRUE; ------------------ | | 818| 267|#define TRUE (!FALSE) | | ------------------ | | | | 814| 267|#define FALSE (0) | | ------------------ ------------------ 865| 267|} fu-coswid-firmware.c:fu_coswid_firmware_init: 1307| 3.85k|{ 1308| 3.85k| FuCoswidFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 40| 3.85k|#define GET_PRIVATE(o) (fu_coswid_firmware_get_instance_private(o)) ------------------ 1309| 3.85k| priv->version_scheme = FU_COSWID_VERSION_SCHEME_SEMVER; 1310| 3.85k| priv->links = g_ptr_array_new_with_free_func((GDestroyNotify)fu_coswid_firmware_link_free); 1311| 3.85k| priv->payloads = 1312| 3.85k| g_ptr_array_new_with_free_func((GDestroyNotify)fu_coswid_firmware_payload_free); 1313| 3.85k| priv->entities = 1314| 3.85k| g_ptr_array_new_with_free_func((GDestroyNotify)fu_coswid_firmware_entity_free); 1315| 3.85k| fu_firmware_add_flag(FU_FIRMWARE(self), FU_FIRMWARE_FLAG_ALLOW_LINEAR); 1316| 3.85k| fu_firmware_set_size_max(FU_FIRMWARE(self), 1 * FU_MB); ------------------ | | 79| 3.85k|#define FU_MB (1ull << 20) ------------------ 1317| 3.85k|} fu_firmware_add_flag: 95| 7.70k|{ 96| 7.70k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 7.70k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 97| 7.70k| g_return_if_fail(FU_IS_FIRMWARE(self)); ------------------ | | 630| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 631| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 632| 7.70k| { } \ | | 633| 7.70k| else \ | | 634| 7.70k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 98| 7.70k| priv->flags |= flag; 99| 7.70k|} fu_firmware_has_flag: 114| 3.85k|{ 115| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 116| 3.85k| g_return_val_if_fail(FU_IS_FIRMWARE(self), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 117| 3.85k| return (priv->flags & flag) > 0; 118| 3.85k|} fu_firmware_get_version: 132| 2.58k|{ 133| 2.58k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 2.58k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 134| 2.58k| g_return_val_if_fail(FU_IS_FIRMWARE(self), NULL); ------------------ | | 643| 2.58k| G_STMT_START { \ | | ------------------ | | | | 874| 2.58k|#define G_STMT_START do | | ------------------ | | 644| 2.58k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.58k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.58k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.58k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.58k| int _g_boolean_var_; \ | | | | | | 1018| 2.58k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.58k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.58k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.58k| else \ | | | | | | 1021| 2.58k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.58k| _g_boolean_var_; \ | | | | | | 1023| 2.58k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.58k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.58k| { } \ | | 646| 2.58k| else \ | | 647| 2.58k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.58k| } G_STMT_END | | ------------------ | | | | 882| 2.58k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.58k] | | | | ------------------ | | ------------------ ------------------ 135| 2.58k| return priv->version; 136| 2.58k|} fu_firmware_set_version: 149| 361|{ 150| 361| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 361|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 151| 361| g_return_if_fail(FU_IS_FIRMWARE(self)); ------------------ | | 630| 361| G_STMT_START { \ | | ------------------ | | | | 874| 361|#define G_STMT_START do | | ------------------ | | 631| 361| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 361|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 361| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 361|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 361| int _g_boolean_var_; \ | | | | | | 1018| 361| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 361, False: 0] | | | | | | ------------------ | | | | | | 1019| 361| _g_boolean_var_ = 1; \ | | | | | | 1020| 361| else \ | | | | | | 1021| 361| _g_boolean_var_ = 0; \ | | | | | | 1022| 361| _g_boolean_var_; \ | | | | | | 1023| 361|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 361, False: 0] | | | | ------------------ | | ------------------ | | 632| 361| { } \ | | 633| 361| else \ | | 634| 361| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 361| } G_STMT_END | | ------------------ | | | | 882| 361|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 361] | | | | ------------------ | | ------------------ ------------------ 152| | 153| | /* not changed */ 154| 361| if (g_strcmp0(priv->version, version) == 0) ------------------ | Branch (154:6): [True: 38, False: 323] ------------------ 155| 38| return; 156| | 157| 323| g_free(priv->version); 158| 323| priv->version = g_strdup(version); 159| 323|} fu_firmware_set_id: 307| 380|{ 308| 380| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 380|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 309| 380| g_return_if_fail(FU_IS_FIRMWARE(self)); ------------------ | | 630| 380| G_STMT_START { \ | | ------------------ | | | | 874| 380|#define G_STMT_START do | | ------------------ | | 631| 380| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 380|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 380| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 380|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 380| int _g_boolean_var_; \ | | | | | | 1018| 380| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 380, False: 0] | | | | | | ------------------ | | | | | | 1019| 380| _g_boolean_var_ = 1; \ | | | | | | 1020| 380| else \ | | | | | | 1021| 380| _g_boolean_var_ = 0; \ | | | | | | 1022| 380| _g_boolean_var_; \ | | | | | | 1023| 380|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 380, False: 0] | | | | ------------------ | | ------------------ | | 632| 380| { } \ | | 633| 380| else \ | | 634| 380| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 380| } G_STMT_END | | ------------------ | | | | 882| 380|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 380] | | | | ------------------ | | ------------------ ------------------ 310| | 311| | /* not changed */ 312| 380| if (g_strcmp0(priv->id, id) == 0) ------------------ | Branch (312:6): [True: 22, False: 358] ------------------ 313| 22| return; 314| | 315| 358| g_free(priv->id); 316| 358| priv->id = g_strdup(id); 317| 358|} fu_firmware_get_id: 331| 2.98k|{ 332| 2.98k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 2.98k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 333| 2.98k| g_return_val_if_fail(FU_IS_FIRMWARE(self), NULL); ------------------ | | 643| 2.98k| G_STMT_START { \ | | ------------------ | | | | 874| 2.98k|#define G_STMT_START do | | ------------------ | | 644| 2.98k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.98k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.98k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.98k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.98k| int _g_boolean_var_; \ | | | | | | 1018| 2.98k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.98k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.98k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.98k| else \ | | | | | | 1021| 2.98k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.98k| _g_boolean_var_; \ | | | | | | 1023| 2.98k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.98k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.98k| { } \ | | 646| 2.98k| else \ | | 647| 2.98k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.98k| } G_STMT_END | | ------------------ | | | | 882| 2.98k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.98k] | | | | ------------------ | | ------------------ ------------------ 334| 2.98k| return priv->id; 335| 2.98k|} fu_firmware_set_offset: 383| 3.85k|{ 384| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 385| 3.85k| g_return_if_fail(FU_IS_FIRMWARE(self)); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 386| 3.85k| priv->offset = offset; 387| 3.85k|} fu_firmware_set_parent: 436| 3.85k|{ 437| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 438| 3.85k| g_return_if_fail(FU_IS_FIRMWARE(self)); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 439| | 440| 3.85k| if (priv->parent != NULL) ------------------ | Branch (440:6): [True: 0, False: 3.85k] ------------------ 441| 0| g_object_remove_weak_pointer(G_OBJECT(priv->parent), (gpointer *)&priv->parent); ------------------ | | 56| 0|#define G_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject)) | | ------------------ | | | | 484| 0|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 0| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 442| 3.85k| if (parent != NULL) ------------------ | Branch (442:6): [True: 0, False: 3.85k] ------------------ 443| 0| g_object_add_weak_pointer(G_OBJECT(parent), (gpointer *)&priv->parent); ------------------ | | 56| 0|#define G_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject)) | | ------------------ | | | | 484| 0|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 0| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 444| 3.85k| priv->parent = parent; 445| 3.85k|} fu_firmware_set_size: 459| 2.63k|{ 460| 2.63k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 2.63k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 461| 2.63k| g_return_if_fail(FU_IS_FIRMWARE(self)); ------------------ | | 630| 2.63k| G_STMT_START { \ | | ------------------ | | | | 874| 2.63k|#define G_STMT_START do | | ------------------ | | 631| 2.63k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.63k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.63k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.63k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.63k| int _g_boolean_var_; \ | | | | | | 1018| 2.63k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.63k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.63k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.63k| else \ | | | | | | 1021| 2.63k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.63k| _g_boolean_var_; \ | | | | | | 1023| 2.63k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.63k, False: 0] | | | | ------------------ | | ------------------ | | 632| 2.63k| { } \ | | 633| 2.63k| else \ | | 634| 2.63k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 2.63k| } G_STMT_END | | ------------------ | | | | 882| 2.63k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.63k] | | | | ------------------ | | ------------------ ------------------ 462| 2.63k| priv->size = size; 463| 2.63k|} fu_firmware_set_size_max: 506| 3.85k|{ 507| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 508| 3.85k| g_return_if_fail(FU_IS_FIRMWARE(self)); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 509| 3.85k| priv->size_max = size_max; 510| 3.85k|} fu_firmware_parse_stream: 1101| 3.85k|{ 1102| 3.85k| FuFirmwareClass *klass = FU_FIRMWARE_GET_CLASS(self); 1103| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 1104| 3.85k| gsize streamsz = 0; 1105| 3.85k| g_autoptr(GInputStream) partial_stream = NULL; ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1106| 3.85k| g_autoptr(GInputStream) seekable_stream = NULL; ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1107| 3.85k| g_autoptr(GBytes) blob = NULL; ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1108| | 1109| 3.85k| g_return_val_if_fail(FU_IS_FIRMWARE(self), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 1110| 3.85k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 26.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 1111| 3.85k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 1112| | 1113| | /* sanity check */ 1114| 3.85k| if (fu_firmware_has_flag(self, FU_FIRMWARE_FLAG_DONE_PARSE)) { ------------------ | Branch (1114:6): [True: 0, False: 3.85k] ------------------ 1115| 0| g_set_error_literal(error, 1116| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 1117| 0| FWUPD_ERROR_NOT_SUPPORTED, 1118| 0| "firmware object cannot be reused"); 1119| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1120| 0| } 1121| | 1122| | /* ensure the stream is seekable */ 1123| 3.85k| if (!G_IS_SEEKABLE(stream) || !g_seekable_can_seek(G_SEEKABLE(stream))) { ------------------ | | 34| 7.70k|#define G_IS_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_SEEKABLE)) | | ------------------ | | | | 497| 3.85k|#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type) (_G_TYPE_CIT ((instance), (g_type))) | | | | ------------------ | | | | | | 2313| 3.85k|# define _G_TYPE_CIT(ip, gt) (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 2314| 3.85k| GTypeInstance *__inst = (GTypeInstance*) ip; GType __t = gt; gboolean __r; \ | | | | | | 2315| 3.85k| if (!__inst) \ | | | | | | ------------------ | | | | | | | Branch (2315:7): [True: 0, False: 3.85k] | | | | | | ------------------ | | | | | | 2316| 3.85k| __r = FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | 2317| 3.85k| else if (__inst->g_class && __inst->g_class->g_type == __t) \ | | | | | | ------------------ | | | | | | | Branch (2317:12): [True: 3.85k, False: 0] | | | | | | | Branch (2317:31): [True: 0, False: 3.85k] | | | | | | ------------------ | | | | | | 2318| 3.85k| __r = TRUE; \ | | | | | | ------------------ | | | | | | | | 818| 0|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 0|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2319| 3.85k| else \ | | | | | | 2320| 3.85k| __r = g_type_check_instance_is_a (__inst, __t); \ | | | | | | 2321| 3.85k| __r; \ | | | | | | 2322| 3.85k|})) | | | | ------------------ | | ------------------ ------------------ if (!G_IS_SEEKABLE(stream) || !g_seekable_can_seek(G_SEEKABLE(stream))) { ------------------ | | 33| 3.85k|#define G_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ | Branch (1123:6): [True: 0, False: 3.85k] | Branch (1123:32): [True: 0, False: 3.85k] ------------------ 1124| 0| blob = fu_input_stream_read_bytes(stream, offset, G_MAXUINT32, NULL, error); ------------------ | | 92| 0|#define G_MAXUINT32 ((guint32) 0xffffffff) ------------------ 1125| 0| if (blob == NULL) ------------------ | Branch (1125:7): [True: 0, False: 0] ------------------ 1126| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1127| 0| seekable_stream = g_memory_input_stream_new_from_bytes(blob); 1128| 3.85k| } else { 1129| 3.85k| seekable_stream = g_object_ref(stream); ------------------ | | 523| 3.85k|#define g_object_ref(Obj) ((glib_typeof (Obj)) (g_object_ref) (Obj)) ------------------ 1130| 3.85k| } 1131| | 1132| | /* check size */ 1133| 3.85k| if (!fu_input_stream_size(seekable_stream, &streamsz, error)) ------------------ | Branch (1133:6): [True: 0, False: 3.85k] ------------------ 1134| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1135| 3.85k| if (streamsz <= offset) { ------------------ | Branch (1135:6): [True: 0, False: 3.85k] ------------------ 1136| 0| g_set_error(error, 1137| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 1138| 0| FWUPD_ERROR_NOT_SUPPORTED, 1139| 0| "stream size 0x%x is smaller than offset 0x%x", 1140| 0| (guint)streamsz, 1141| 0| (guint)offset); 1142| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1143| 0| } 1144| | 1145| | /* optional */ 1146| 3.85k| if (!fu_firmware_validate_for_offset(self, seekable_stream, offset, &offset, flags, error)) ------------------ | Branch (1146:6): [True: 0, False: 3.85k] ------------------ 1147| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1148| 3.85k| fu_firmware_set_offset(self, offset); 1149| | 1150| | /* validate offset hasn't been corrupted */ 1151| 3.85k| if (offset >= streamsz) { ------------------ | Branch (1151:6): [True: 0, False: 3.85k] ------------------ 1152| 0| g_set_error(error, 1153| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 1154| 0| FWUPD_ERROR_INVALID_FILE, 1155| 0| "offset 0x%x exceeds stream size 0x%x", 1156| 0| (guint)offset, 1157| 0| (guint)streamsz); 1158| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1159| 0| } 1160| | 1161| | /* save stream size */ 1162| 3.85k| priv->streamsz = streamsz - offset; 1163| 3.85k| if (priv->streamsz == 0) { ------------------ | Branch (1163:6): [True: 0, False: 3.85k] ------------------ 1164| 0| g_set_error_literal(error, 1165| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 1166| 0| FWUPD_ERROR_NOT_SUPPORTED, 1167| 0| "invalid firmware as zero sized"); 1168| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1169| 0| } 1170| 3.85k| if (priv->size_max > 0 && priv->streamsz > priv->size_max) { ------------------ | Branch (1170:6): [True: 3.85k, False: 0] | Branch (1170:28): [True: 0, False: 3.85k] ------------------ 1171| 0| g_autofree gchar *sz_val = g_format_size(priv->streamsz); ------------------ | | 1167| 0|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 0|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1172| 0| g_autofree gchar *sz_max = g_format_size(priv->size_max); ------------------ | | 1167| 0|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 0|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1173| 0| g_set_error(error, 1174| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 1175| 0| FWUPD_ERROR_INVALID_FILE, 1176| 0| "%s firmware is too large (%s, limit %s)", 1177| 0| G_OBJECT_TYPE_NAME(self), ------------------ | | 110| 0|#define G_OBJECT_TYPE_NAME(object) (g_type_name (G_OBJECT_TYPE (object))) | | ------------------ | | | | 100| 0|#define G_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object)) | | | | ------------------ | | | | | | 602| 0|#define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class)) | | | | | | ------------------ | | | | | | | | 613| 0|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1178| 0| sz_val, 1179| 0| sz_max); 1180| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1181| 0| } 1182| | 1183| 3.85k|#ifndef SUPPORTED_BUILD 1184| | /* we want all firmware subclasses to set this now */ 1185| 3.85k| if (G_OBJECT_TYPE(self) != FU_TYPE_FIRMWARE && ------------------ | | 100| 3.85k|#define G_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object)) | | ------------------ | | | | 602| 3.85k|#define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class)) | | | | ------------------ | | | | | | 613| 3.85k|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) | | | | ------------------ | | ------------------ ------------------ if (G_OBJECT_TYPE(self) != FU_TYPE_FIRMWARE && ------------------ | | 15| 7.70k|#define FU_TYPE_FIRMWARE (fu_firmware_get_type()) ------------------ | Branch (1185:6): [True: 3.85k, False: 0] ------------------ 1186| 3.85k| priv->size_max == FU_FIRMWARE_SIZE_MAX_DEFAULT) { ------------------ | | 11| 3.85k|#define FU_FIRMWARE_SIZE_MAX_DEFAULT ((100 * FU_MB) + 1) | | ------------------ | | | | 79| 3.85k|#define FU_MB (1ull << 20) | | ------------------ ------------------ | Branch (1186:6): [True: 0, False: 3.85k] ------------------ 1187| 0| g_critical("%s did not set firmware max size with fu_firmware_set_size_max()", ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1188| 0| G_OBJECT_TYPE_NAME(self)); 1189| 0| } 1190| 3.85k|#endif 1191| | 1192| | /* any FuFirmware subclass that gets past this point might have allocated memory in 1193| | * ->tokenize() or ->parse() and needs to be destroyed before parsing again */ 1194| 3.85k| fu_firmware_add_flag(self, FU_FIRMWARE_FLAG_DONE_PARSE); 1195| | 1196| | /* this allows devices to skip reading the old firmware if the GType is unsuitable */ 1197| 3.85k| if (klass->check_compatible != NULL) ------------------ | Branch (1197:6): [True: 0, False: 3.85k] ------------------ 1198| 0| fu_firmware_add_flag(self, FU_FIRMWARE_FLAG_HAS_CHECK_COMPATIBLE); 1199| | 1200| | /* save stream */ 1201| 3.85k| if (offset == 0) { ------------------ | Branch (1201:6): [True: 3.85k, False: 0] ------------------ 1202| 3.85k| partial_stream = g_object_ref(seekable_stream); ------------------ | | 523| 3.85k|#define g_object_ref(Obj) ((glib_typeof (Obj)) (g_object_ref) (Obj)) ------------------ 1203| 3.85k| } else { 1204| 0| partial_stream = 1205| 0| fu_partial_input_stream_new(seekable_stream, offset, priv->streamsz, error); 1206| 0| if (partial_stream == NULL) { ------------------ | Branch (1206:7): [True: 0, False: 0] ------------------ 1207| 0| g_prefix_error_literal(error, "failed to cut firmware: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 1208| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1209| 0| } 1210| 0| } 1211| | 1212| | /* cache */ 1213| 3.85k| if (flags & FU_FIRMWARE_PARSE_FLAG_CACHE_BLOB) { ------------------ | Branch (1213:6): [True: 0, False: 3.85k] ------------------ 1214| 0| if (blob == NULL) { ------------------ | Branch (1214:7): [True: 0, False: 0] ------------------ 1215| 0| blob = fu_input_stream_read_bytes(partial_stream, 1216| 0| 0x0, 1217| 0| priv->streamsz, 1218| 0| NULL, 1219| 0| error); 1220| 0| if (blob == NULL) ------------------ | Branch (1220:8): [True: 0, False: 0] ------------------ 1221| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1222| 0| } 1223| 0| fu_firmware_set_bytes(self, blob); 1224| 0| } 1225| 3.85k| if (flags & FU_FIRMWARE_PARSE_FLAG_CACHE_STREAM) ------------------ | Branch (1225:6): [True: 0, False: 3.85k] ------------------ 1226| 0| g_set_object(&priv->stream, partial_stream); ------------------ | | 750| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 751| 0| G_STATIC_ASSERT (sizeof *(object_ptr) == sizeof (new_object)); \ | | ------------------ | | | | 758| 0|#define G_STATIC_ASSERT(expr) _Static_assert (expr, "Expression evaluates to false") | | ------------------ | | 752| 0| /* Only one access, please; work around type aliasing */ \ | | 753| 0| union { char *in; GObject **out; } _object_ptr; \ | | 754| 0| _object_ptr.in = (char *) (object_ptr); \ | | 755| 0| /* Check types match */ \ | | 756| 0| (void) (0 ? *(object_ptr) = (new_object), FALSE : FALSE); \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | (void) (0 ? *(object_ptr) = (new_object), FALSE : FALSE); \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (756:13): [Folded, False: 0] | | ------------------ | | 757| 0| (g_set_object) (_object_ptr.out, (GObject *) new_object); \ | | 758| 0| })) \ | | 759| 3.85k| GLIB_AVAILABLE_MACRO_IN_2_44 ------------------ 1227| | 1228| | /* optional */ 1229| 3.85k| if (klass->tokenize != NULL) { ------------------ | Branch (1229:6): [True: 0, False: 3.85k] ------------------ 1230| 0| if (!klass->tokenize(self, partial_stream, flags, error)) ------------------ | Branch (1230:7): [True: 0, False: 0] ------------------ 1231| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1232| 0| } 1233| | 1234| | /* optional */ 1235| 3.85k| if (klass->parse_full != NULL) ------------------ | Branch (1235:6): [True: 0, False: 3.85k] ------------------ 1236| 0| return klass->parse_full(self, seekable_stream, offset, flags, error); 1237| 3.85k| else if (klass->parse != NULL) ------------------ | Branch (1237:11): [True: 3.85k, False: 0] ------------------ 1238| 3.85k| return klass->parse(self, partial_stream, flags, error); 1239| | 1240| | /* verify alignment */ 1241| 0| if (streamsz % (1ull << priv->alignment) != 0) { ------------------ | Branch (1241:6): [True: 0, False: 0] ------------------ 1242| 0| g_autofree gchar *str = NULL; ------------------ | | 1167| 0|#define g_autofree _GLIB_CLEANUP(g_autoptr_cleanup_generic_gfree) | | ------------------ | | | | 1129| 0|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1243| 0| str = g_format_size_full(1ull << priv->alignment, G_FORMAT_SIZE_IEC_UNITS); 1244| 0| g_set_error(error, 1245| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 1246| 0| FWUPD_ERROR_INVALID_FILE, 1247| 0| "raw firmware is not aligned to 0x%x (%s)", 1248| 0| (guint)(1ull << priv->alignment), 1249| 0| str); 1250| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1251| 0| } 1252| | 1253| | /* success */ 1254| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 1255| 0|} fu_firmware_parse_bytes: 1277| 3.85k|{ 1278| 3.85k| g_autoptr(GInputStream) stream = NULL; ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1279| | 1280| 3.85k| g_return_val_if_fail(FU_IS_FIRMWARE(self), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 1281| 3.85k| g_return_val_if_fail(fw != NULL, FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 1282| 3.85k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 1283| | 1284| 3.85k| stream = g_memory_input_stream_new_from_bytes(fw); 1285| 3.85k| return fu_firmware_parse_stream(self, stream, offset, flags, error); 1286| 3.85k|} fu_firmware_write: 1661| 761|{ 1662| 761| FuFirmwareClass *klass = FU_FIRMWARE_GET_CLASS(self); 1663| | 1664| 761| g_return_val_if_fail(FU_IS_FIRMWARE(self), NULL); ------------------ | | 643| 761| G_STMT_START { \ | | ------------------ | | | | 874| 761|#define G_STMT_START do | | ------------------ | | 644| 761| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 761|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 761| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 761|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 761| int _g_boolean_var_; \ | | | | | | 1018| 761| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 761, False: 0] | | | | | | ------------------ | | | | | | 1019| 761| _g_boolean_var_ = 1; \ | | | | | | 1020| 761| else \ | | | | | | 1021| 761| _g_boolean_var_ = 0; \ | | | | | | 1022| 761| _g_boolean_var_; \ | | | | | | 1023| 761|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 761, False: 0] | | | | ------------------ | | ------------------ | | 645| 761| { } \ | | 646| 761| else \ | | 647| 761| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 761| } G_STMT_END | | ------------------ | | | | 882| 761|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 761] | | | | ------------------ | | ------------------ ------------------ 1665| 761| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 761| G_STMT_START { \ | | ------------------ | | | | 874| 761|#define G_STMT_START do | | ------------------ | | 644| 761| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 761|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 761| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 761|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 761| int _g_boolean_var_; \ | | | | | | 1018| 1.52k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 761, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 761| _g_boolean_var_ = 1; \ | | | | | | 1020| 761| else \ | | | | | | 1021| 761| _g_boolean_var_ = 0; \ | | | | | | 1022| 761| _g_boolean_var_; \ | | | | | | 1023| 761|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 761, False: 0] | | | | ------------------ | | ------------------ | | 645| 761| { } \ | | 646| 761| else \ | | 647| 761| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 761| } G_STMT_END | | ------------------ | | | | 882| 761|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 761] | | | | ------------------ | | ------------------ ------------------ 1666| | 1667| | /* subclassed */ 1668| 761| if (klass->write != NULL) { ------------------ | Branch (1668:6): [True: 761, False: 0] ------------------ 1669| 761| g_autoptr(GByteArray) buf = klass->write(self, error); ------------------ | | 1162| 761|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 761|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 1670| 761| if (buf == NULL) ------------------ | Branch (1670:7): [True: 0, False: 761] ------------------ 1671| 0| return NULL; 1672| 761| return g_bytes_new(buf->data, buf->len); 1673| 761| } 1674| | 1675| | /* just add default blob */ 1676| 0| return fu_firmware_get_bytes_with_patches(self, error); 1677| 761|} fu-firmware.c:fu_firmware_class_init: 2746| 1|{ 2747| 1| GObjectClass *object_class = G_OBJECT_CLASS(klass); ------------------ | | 63| 1|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 1|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 1| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 2748| 1| GParamSpec *pspec; 2749| | 2750| 1| object_class->finalize = fu_firmware_finalize; 2751| 1| object_class->get_property = fu_firmware_get_property; 2752| 1| object_class->set_property = fu_firmware_set_property; 2753| 1| object_class->constructed = fu_firmware_constructed; 2754| | 2755| | /** 2756| | * FuFirmware:parent: 2757| | * 2758| | * The firmware parent. 2759| | * 2760| | * Since: 1.8.2 2761| | */ 2762| 1| pspec = g_param_spec_object("parent", 2763| 1| NULL, 2764| 1| NULL, 2765| 1| FU_TYPE_FIRMWARE, ------------------ | | 15| 1|#define FU_TYPE_FIRMWARE (fu_firmware_get_type()) ------------------ 2766| 1| G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_NAME); 2767| 1| g_object_class_install_property(object_class, PROP_PARENT, pspec); 2768| 1|} fu-firmware.c:fu_firmware_finalize: 2720| 3.85k|{ 2721| 3.85k| FuFirmware *self = FU_FIRMWARE(object); 2722| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 2723| 3.85k| g_free(priv->version); 2724| 3.85k| g_free(priv->id); 2725| 3.85k| g_free(priv->filename); 2726| 3.85k| if (priv->bytes != NULL) ------------------ | Branch (2726:6): [True: 0, False: 3.85k] ------------------ 2727| 0| g_bytes_unref(priv->bytes); 2728| 3.85k| if (priv->stream != NULL) ------------------ | Branch (2728:6): [True: 0, False: 3.85k] ------------------ 2729| 0| g_object_unref(priv->stream); 2730| 3.85k| if (priv->chunks != NULL) ------------------ | Branch (2730:6): [True: 0, False: 3.85k] ------------------ 2731| 0| g_ptr_array_unref(priv->chunks); 2732| 3.85k| if (priv->image_gtypes != NULL) ------------------ | Branch (2732:6): [True: 0, False: 3.85k] ------------------ 2733| 0| g_array_unref(priv->image_gtypes); 2734| 3.85k| if (priv->patches != NULL) ------------------ | Branch (2734:6): [True: 0, False: 3.85k] ------------------ 2735| 0| g_ptr_array_unref(priv->patches); 2736| 3.85k| if (priv->magic != NULL) ------------------ | Branch (2736:6): [True: 0, False: 3.85k] ------------------ 2737| 0| g_ptr_array_unref(priv->magic); 2738| 3.85k| if (priv->parent != NULL) ------------------ | Branch (2738:6): [True: 0, False: 3.85k] ------------------ 2739| 0| g_object_remove_weak_pointer(G_OBJECT(priv->parent), (gpointer *)&priv->parent); ------------------ | | 56| 0|#define G_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject)) | | ------------------ | | | | 484| 0|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 0| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 2740| 3.85k| g_ptr_array_unref(priv->images); 2741| 3.85k| G_OBJECT_CLASS(fu_firmware_parent_class)->finalize(object); ------------------ | | 63| 3.85k|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 3.85k|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 3.85k| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 2742| 3.85k|} fu-firmware.c:fu_firmware_set_property: 2683| 3.85k|{ 2684| 3.85k| FuFirmware *self = FU_FIRMWARE(object); 2685| 3.85k| switch (prop_id) { 2686| 3.85k| case PROP_PARENT: ------------------ | Branch (2686:2): [True: 3.85k, False: 0] ------------------ 2687| 3.85k| fu_firmware_set_parent(self, g_value_get_object(value)); 2688| 3.85k| break; 2689| 0| default: ------------------ | Branch (2689:2): [True: 0, False: 3.85k] ------------------ 2690| 0| G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); ------------------ | | 679| 0| G_OBJECT_WARN_INVALID_PSPEC ((object), "property", (property_id), (pspec)) | | ------------------ | | | | 656| 0|#define G_OBJECT_WARN_INVALID_PSPEC(object, pname, property_id, pspec) \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 657| 0|G_STMT_START { \ | | | | 658| 0| GObject *_glib__object = (GObject*) (object); \ | | | | 659| 0| GParamSpec *_glib__pspec = (GParamSpec*) (pspec); \ | | | | 660| 0| guint _glib__property_id = (property_id); \ | | | | 661| 0| g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'", \ | | | | ------------------ | | | | | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 7| 0|#define G_LOG_DOMAIN "FuFirmware" | | | | | | ------------------ | | | | | | 346| 0| G_LOG_LEVEL_WARNING, \ | | | | | | 347| 0| __VA_ARGS__) | | | | ------------------ | | | | 662| 0| __FILE__, __LINE__, \ | | | | 663| 0| (pname), \ | | | | 664| 0| _glib__property_id, \ | | | | 665| 0| _glib__pspec->name, \ | | | | 666| 0| g_type_name (G_PARAM_SPEC_TYPE (_glib__pspec)), \ | | | | 667| 0| G_OBJECT_TYPE_NAME (_glib__object)); \ | | | | 668| 0|} G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2691| 0| break; 2692| 3.85k| } 2693| 3.85k|} fu-firmware.c:fu_firmware_constructed: 2705| 3.85k|{ 2706| 3.85k| FuFirmware *self = FU_FIRMWARE(obj); 2707| 3.85k| FuFirmwareClass *klass = FU_FIRMWARE_GET_CLASS(self); 2708| 3.85k| if (klass->add_magic != NULL) ------------------ | Branch (2708:6): [True: 0, False: 3.85k] ------------------ 2709| 0| klass->add_magic(self); 2710| 3.85k| if (G_TYPE_FROM_CLASS(klass) != FU_TYPE_FIRMWARE && klass->parse_full == NULL && ------------------ | | 613| 3.85k|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) ------------------ if (G_TYPE_FROM_CLASS(klass) != FU_TYPE_FIRMWARE && klass->parse_full == NULL && ------------------ | | 15| 7.70k|#define FU_TYPE_FIRMWARE (fu_firmware_get_type()) ------------------ | Branch (2710:6): [True: 3.85k, False: 0] | Branch (2710:54): [True: 3.85k, False: 0] ------------------ 2711| 3.85k| klass->parse == NULL) ------------------ | Branch (2711:6): [True: 0, False: 3.85k] ------------------ 2712| 0| fu_firmware_add_flag(self, FU_FIRMWARE_FLAG_IS_ABSTRACT); 2713| | 2714| | /* chain up to parent */ 2715| 3.85k| G_OBJECT_CLASS(fu_firmware_parent_class)->constructed(obj); ------------------ | | 63| 3.85k|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 3.85k|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 3.85k| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 2716| 3.85k|} fu-firmware.c:fu_firmware_init: 2697| 3.85k|{ 2698| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 2699| 3.85k| priv->images = g_ptr_array_new_with_free_func((GDestroyNotify)g_object_unref); 2700| 3.85k| priv->size_max = FU_FIRMWARE_SIZE_MAX_DEFAULT; ------------------ | | 11| 3.85k|#define FU_FIRMWARE_SIZE_MAX_DEFAULT ((100 * FU_MB) + 1) | | ------------------ | | | | 79| 3.85k|#define FU_MB (1ull << 20) | | ------------------ ------------------ 2701| 3.85k|} fu-firmware.c:fu_firmware_fuzzer_iface_init: 3076| 1|{ 3077| 1| iface->test_input = fu_firmware_fuzzer_test_input; 3078| 1| iface->build_example = fu_firmware_fuzzer_build_example; 3079| 1|} fu-firmware.c:fu_firmware_fuzzer_test_input: 3014| 3.85k|{ 3015| 3.85k| FuFirmware *self = FU_FIRMWARE(fuzzer); 3016| 3.85k| g_autoptr(GBytes) fw = NULL; ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 3017| | 3018| 3.85k| if (!fu_firmware_parse_bytes(self, ------------------ | Branch (3018:6): [True: 3.09k, False: 761] ------------------ 3019| 3.85k| blob, 3020| 3.85k| 0x0, 3021| 3.85k| FU_FIRMWARE_PARSE_FLAG_NO_SEARCH | 3022| 3.85k| FU_FIRMWARE_PARSE_FLAG_IGNORE_VID_PID | 3023| 3.85k| FU_FIRMWARE_PARSE_FLAG_IGNORE_CHECKSUM, 3024| 3.85k| error)) 3025| 3.09k| return FALSE; ------------------ | | 814| 3.09k|#define FALSE (0) ------------------ 3026| 761| fw = fu_firmware_write(self, error); 3027| 761| if (fw == NULL) ------------------ | Branch (3027:6): [True: 0, False: 761] ------------------ 3028| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 3029| | 3030| | /* success */ 3031| 761| return TRUE; ------------------ | | 818| 761|#define TRUE (!FALSE) | | ------------------ | | | | 814| 761|#define FALSE (0) | | ------------------ ------------------ 3032| 761|} fu-firmware.c:fu_firmware_validate_for_offset: 1046| 3.85k|{ 1047| 3.85k| FuFirmwareClass *klass = FU_FIRMWARE_GET_CLASS(self); 1048| 3.85k| FuFirmwarePrivate *priv = GET_PRIVATE(self); ------------------ | | 66| 3.85k|#define GET_PRIVATE(o) (fu_firmware_get_instance_private(o)) ------------------ 1049| 3.85k| gsize streamsz = 0; 1050| | 1051| | /* not implemented */ 1052| 3.85k| if (klass->validate == NULL) ------------------ | Branch (1052:6): [True: 3.85k, False: 0] ------------------ 1053| 3.85k| return TRUE; ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 1054| | 1055| | /* fuzzing */ 1056| 0| if (!fu_firmware_has_flag(self, FU_FIRMWARE_FLAG_ALWAYS_SEARCH) && ------------------ | Branch (1056:6): [True: 0, False: 0] ------------------ 1057| 0| (flags & FU_FIRMWARE_PARSE_FLAG_NO_SEARCH) > 0) { ------------------ | Branch (1057:6): [True: 0, False: 0] ------------------ 1058| 0| return klass->validate(self, stream, offset, error); 1059| 0| } 1060| | 1061| | /* try all the magic values, if provided */ 1062| 0| if (priv->magic != NULL) ------------------ | Branch (1062:6): [True: 0, False: 0] ------------------ 1063| 0| return fu_firmware_validate_with_magic(self, stream, offset, offset_found, error); 1064| | 1065| | /* limit the size of firmware we search as brute force is expensive */ 1066| 0| if (!fu_input_stream_size(stream, &streamsz, error)) ------------------ | Branch (1066:6): [True: 0, False: 0] ------------------ 1067| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1068| 0| if (streamsz < FU_FIRMWARE_SEARCH_MAGIC_BUFSZ_MAX) { ------------------ | | 79| 0|#define FU_FIRMWARE_SEARCH_MAGIC_BUFSZ_MAX (64 * FU_KB) | | ------------------ | | | | 70| 0|#define FU_KB (1ull << 10) | | ------------------ ------------------ | Branch (1068:6): [True: 0, False: 0] ------------------ 1069| 0| for (gsize offset_tmp = offset; offset_tmp < streamsz; offset_tmp++) { ------------------ | Branch (1069:35): [True: 0, False: 0] ------------------ 1070| 0| if (klass->validate(self, stream, offset_tmp, NULL)) { ------------------ | Branch (1070:8): [True: 0, False: 0] ------------------ 1071| 0| *offset_found = offset_tmp; 1072| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 1073| 0| } 1074| 0| } 1075| 0| } 1076| | 1077| | /* check in more detail */ 1078| 0| return klass->validate(self, stream, offset, error); 1079| 0|} fu_fuzzer_test_input: 32| 3.85k|{ 33| 3.85k| FuFuzzerInterface *iface = FU_FUZZER_GET_IFACE(self); 34| 3.85k| if (iface->test_input == NULL) { ------------------ | Branch (34:6): [True: 0, False: 3.85k] ------------------ 35| 0| g_set_error_literal(error, 36| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 37| 0| FWUPD_ERROR_NOT_SUPPORTED, 38| 0| "FuFuzzer->test_input() not implemented"); 39| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 40| 0| } 41| 3.85k| return iface->test_input(self, blob, error); 42| 3.85k|} fu-fuzzer.c:fu_fuzzer_default_init: 15| 1|{ 16| 1|} fu_input_stream_read_safe: 70| 114k|{ 71| 114k| gssize rc; 72| | 73| 114k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE); ------------------ | | 643| 114k| G_STMT_START { \ | | ------------------ | | | | 874| 114k|#define G_STMT_START do | | ------------------ | | 644| 114k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 114k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 114k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 114k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 114k| int _g_boolean_var_; \ | | | | | | 1018| 800k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 114k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 114k] | | | | | | | Branch (1018:8): [True: 0, False: 114k] | | | | | | | Branch (1018:8): [True: 114k, False: 0] | | | | | | ------------------ | | | | | | 1019| 114k| _g_boolean_var_ = 1; \ | | | | | | 1020| 114k| else \ | | | | | | 1021| 114k| _g_boolean_var_ = 0; \ | | | | | | 1022| 114k| _g_boolean_var_; \ | | | | | | 1023| 114k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 114k, False: 0] | | | | ------------------ | | ------------------ | | 645| 114k| { } \ | | 646| 114k| else \ | | 647| 114k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 114k| } G_STMT_END | | ------------------ | | | | 882| 114k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 114k] | | | | ------------------ | | ------------------ ------------------ 74| 114k| g_return_val_if_fail(buf != NULL, FALSE); ------------------ | | 643| 114k| G_STMT_START { \ | | ------------------ | | | | 874| 114k|#define G_STMT_START do | | ------------------ | | 644| 114k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 114k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 114k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 114k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 114k| int _g_boolean_var_; \ | | | | | | 1018| 114k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 114k, False: 0] | | | | | | ------------------ | | | | | | 1019| 114k| _g_boolean_var_ = 1; \ | | | | | | 1020| 114k| else \ | | | | | | 1021| 114k| _g_boolean_var_ = 0; \ | | | | | | 1022| 114k| _g_boolean_var_; \ | | | | | | 1023| 114k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 114k, False: 0] | | | | ------------------ | | ------------------ | | 645| 114k| { } \ | | 646| 114k| else \ | | 647| 114k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 114k| } G_STMT_END | | ------------------ | | | | 882| 114k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 114k] | | | | ------------------ | | ------------------ ------------------ 75| 114k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 114k| G_STMT_START { \ | | ------------------ | | | | 874| 114k|#define G_STMT_START do | | ------------------ | | 644| 114k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 114k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 114k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 114k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 114k| int _g_boolean_var_; \ | | | | | | 1018| 228k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 114k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 114k| _g_boolean_var_ = 1; \ | | | | | | 1020| 114k| else \ | | | | | | 1021| 114k| _g_boolean_var_ = 0; \ | | | | | | 1022| 114k| _g_boolean_var_; \ | | | | | | 1023| 114k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 114k, False: 0] | | | | ------------------ | | ------------------ | | 645| 114k| { } \ | | 646| 114k| else \ | | 647| 114k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 114k| } G_STMT_END | | ------------------ | | | | 882| 114k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 114k] | | | | ------------------ | | ------------------ ------------------ 76| | 77| 114k| if (!fu_memchk_write(bufsz, offset, count, error)) ------------------ | Branch (77:6): [True: 0, False: 114k] ------------------ 78| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 79| 114k| if (!g_seekable_seek(G_SEEKABLE(stream), seek_set, G_SEEK_SET, NULL, error)) { ------------------ | | 33| 114k|#define G_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable)) | | ------------------ | | | | 484| 114k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 114k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ | Branch (79:6): [True: 15, False: 114k] ------------------ 80| 15| g_prefix_error(error, "seek to 0x%x: ", (guint)seek_set); 81| 15| return FALSE; ------------------ | | 814| 15|#define FALSE (0) ------------------ 82| 15| } 83| 114k| rc = g_input_stream_read(stream, buf + offset, count, NULL, error); 84| 114k| if (rc == -1) { ------------------ | Branch (84:6): [True: 0, False: 114k] ------------------ 85| 0| g_prefix_error(error, "failed read of 0x%x: ", (guint)count); 86| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 87| 0| } 88| 114k| if ((gsize)rc != count) { ------------------ | Branch (88:6): [True: 224, False: 114k] ------------------ 89| 224| g_set_error(error, 90| 224| FWUPD_ERROR, ------------------ | | 15| 224|#define FWUPD_ERROR fwupd_error_quark() ------------------ 91| 224| FWUPD_ERROR_READ, 92| 224| "requested 0x%x and got 0x%x", 93| 224| (guint)count, 94| 224| (guint)rc); 95| 224| return FALSE; ------------------ | | 814| 224|#define FALSE (0) ------------------ 96| 224| } 97| 114k| return TRUE; ------------------ | | 818| 114k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 114k|#define FALSE (0) | | ------------------ ------------------ 98| 114k|} fu_input_stream_read_u8: 115| 111k|{ 116| 111k| guint8 buf = 0; 117| 111k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE); ------------------ | | 643| 111k| G_STMT_START { \ | | ------------------ | | | | 874| 111k|#define G_STMT_START do | | ------------------ | | 644| 111k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 111k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 111k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 111k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 111k| int _g_boolean_var_; \ | | | | | | 1018| 781k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 111k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 111k] | | | | | | | Branch (1018:8): [True: 0, False: 111k] | | | | | | | Branch (1018:8): [True: 111k, False: 0] | | | | | | ------------------ | | | | | | 1019| 111k| _g_boolean_var_ = 1; \ | | | | | | 1020| 111k| else \ | | | | | | 1021| 111k| _g_boolean_var_ = 0; \ | | | | | | 1022| 111k| _g_boolean_var_; \ | | | | | | 1023| 111k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 111k, False: 0] | | | | ------------------ | | ------------------ | | 645| 111k| { } \ | | 646| 111k| else \ | | 647| 111k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 111k| } G_STMT_END | | ------------------ | | | | 882| 111k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 111k] | | | | ------------------ | | ------------------ ------------------ 118| 111k| g_return_val_if_fail(value != NULL, FALSE); ------------------ | | 643| 111k| G_STMT_START { \ | | ------------------ | | | | 874| 111k|#define G_STMT_START do | | ------------------ | | 644| 111k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 111k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 111k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 111k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 111k| int _g_boolean_var_; \ | | | | | | 1018| 111k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 111k, False: 0] | | | | | | ------------------ | | | | | | 1019| 111k| _g_boolean_var_ = 1; \ | | | | | | 1020| 111k| else \ | | | | | | 1021| 111k| _g_boolean_var_ = 0; \ | | | | | | 1022| 111k| _g_boolean_var_; \ | | | | | | 1023| 111k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 111k, False: 0] | | | | ------------------ | | ------------------ | | 645| 111k| { } \ | | 646| 111k| else \ | | 647| 111k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 111k| } G_STMT_END | | ------------------ | | | | 882| 111k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 111k] | | | | ------------------ | | ------------------ ------------------ 119| 111k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 111k| G_STMT_START { \ | | ------------------ | | | | 874| 111k|#define G_STMT_START do | | ------------------ | | 644| 111k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 111k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 111k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 111k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 111k| int _g_boolean_var_; \ | | | | | | 1018| 223k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 111k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 111k| _g_boolean_var_ = 1; \ | | | | | | 1020| 111k| else \ | | | | | | 1021| 111k| _g_boolean_var_ = 0; \ | | | | | | 1022| 111k| _g_boolean_var_; \ | | | | | | 1023| 111k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 111k, False: 0] | | | | ------------------ | | ------------------ | | 645| 111k| { } \ | | 646| 111k| else \ | | 647| 111k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 111k| } G_STMT_END | | ------------------ | | | | 882| 111k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 111k] | | | | ------------------ | | ------------------ ------------------ 120| 111k| if (!fu_input_stream_read_safe(stream, &buf, sizeof(buf), 0x0, offset, sizeof(buf), error)) ------------------ | Branch (120:6): [True: 211, False: 111k] ------------------ 121| 211| return FALSE; ------------------ | | 814| 211|#define FALSE (0) ------------------ 122| 111k| *value = buf; 123| 111k| return TRUE; ------------------ | | 818| 111k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 111k|#define FALSE (0) | | ------------------ ------------------ 124| 111k|} fu_input_stream_read_u16: 146| 928|{ 147| 928| guint8 buf[2] = {0}; 148| 928| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE); ------------------ | | 643| 928| G_STMT_START { \ | | ------------------ | | | | 874| 928|#define G_STMT_START do | | ------------------ | | 644| 928| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 928|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 928| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 928|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 928| int _g_boolean_var_; \ | | | | | | 1018| 6.49k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 928, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 928] | | | | | | | Branch (1018:8): [True: 0, False: 928] | | | | | | | Branch (1018:8): [True: 928, False: 0] | | | | | | ------------------ | | | | | | 1019| 928| _g_boolean_var_ = 1; \ | | | | | | 1020| 928| else \ | | | | | | 1021| 928| _g_boolean_var_ = 0; \ | | | | | | 1022| 928| _g_boolean_var_; \ | | | | | | 1023| 928|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 928, False: 0] | | | | ------------------ | | ------------------ | | 645| 928| { } \ | | 646| 928| else \ | | 647| 928| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 928| } G_STMT_END | | ------------------ | | | | 882| 928|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 928] | | | | ------------------ | | ------------------ ------------------ 149| 928| g_return_val_if_fail(value != NULL, FALSE); ------------------ | | 643| 928| G_STMT_START { \ | | ------------------ | | | | 874| 928|#define G_STMT_START do | | ------------------ | | 644| 928| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 928|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 928| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 928|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 928| int _g_boolean_var_; \ | | | | | | 1018| 928| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 928, False: 0] | | | | | | ------------------ | | | | | | 1019| 928| _g_boolean_var_ = 1; \ | | | | | | 1020| 928| else \ | | | | | | 1021| 928| _g_boolean_var_ = 0; \ | | | | | | 1022| 928| _g_boolean_var_; \ | | | | | | 1023| 928|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 928, False: 0] | | | | ------------------ | | ------------------ | | 645| 928| { } \ | | 646| 928| else \ | | 647| 928| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 928| } G_STMT_END | | ------------------ | | | | 882| 928|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 928] | | | | ------------------ | | ------------------ ------------------ 150| 928| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 928| G_STMT_START { \ | | ------------------ | | | | 874| 928|#define G_STMT_START do | | ------------------ | | 644| 928| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 928|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 928| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 928|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 928| int _g_boolean_var_; \ | | | | | | 1018| 1.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 928, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 928| _g_boolean_var_ = 1; \ | | | | | | 1020| 928| else \ | | | | | | 1021| 928| _g_boolean_var_ = 0; \ | | | | | | 1022| 928| _g_boolean_var_; \ | | | | | | 1023| 928|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 928, False: 0] | | | | ------------------ | | ------------------ | | 645| 928| { } \ | | 646| 928| else \ | | 647| 928| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 928| } G_STMT_END | | ------------------ | | | | 882| 928|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 928] | | | | ------------------ | | ------------------ ------------------ 151| 928| if (!fu_input_stream_read_safe(stream, buf, sizeof(buf), 0x0, offset, sizeof(buf), error)) ------------------ | Branch (151:6): [True: 9, False: 919] ------------------ 152| 9| return FALSE; ------------------ | | 814| 9|#define FALSE (0) ------------------ 153| 919| *value = fu_memread_uint16(buf, endian); 154| 919| return TRUE; ------------------ | | 818| 919|#define TRUE (!FALSE) | | ------------------ | | | | 814| 919|#define FALSE (0) | | ------------------ ------------------ 155| 928|} fu_input_stream_read_u32: 208| 870|{ 209| 870| guint8 buf[4] = {0}; 210| 870| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE); ------------------ | | 643| 870| G_STMT_START { \ | | ------------------ | | | | 874| 870|#define G_STMT_START do | | ------------------ | | 644| 870| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 870|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 870| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 870|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 870| int _g_boolean_var_; \ | | | | | | 1018| 6.09k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 870, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 870] | | | | | | | Branch (1018:8): [True: 0, False: 870] | | | | | | | Branch (1018:8): [True: 870, False: 0] | | | | | | ------------------ | | | | | | 1019| 870| _g_boolean_var_ = 1; \ | | | | | | 1020| 870| else \ | | | | | | 1021| 870| _g_boolean_var_ = 0; \ | | | | | | 1022| 870| _g_boolean_var_; \ | | | | | | 1023| 870|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 870, False: 0] | | | | ------------------ | | ------------------ | | 645| 870| { } \ | | 646| 870| else \ | | 647| 870| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 870| } G_STMT_END | | ------------------ | | | | 882| 870|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 870] | | | | ------------------ | | ------------------ ------------------ 211| 870| g_return_val_if_fail(value != NULL, FALSE); ------------------ | | 643| 870| G_STMT_START { \ | | ------------------ | | | | 874| 870|#define G_STMT_START do | | ------------------ | | 644| 870| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 870|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 870| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 870|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 870| int _g_boolean_var_; \ | | | | | | 1018| 870| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 870, False: 0] | | | | | | ------------------ | | | | | | 1019| 870| _g_boolean_var_ = 1; \ | | | | | | 1020| 870| else \ | | | | | | 1021| 870| _g_boolean_var_ = 0; \ | | | | | | 1022| 870| _g_boolean_var_; \ | | | | | | 1023| 870|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 870, False: 0] | | | | ------------------ | | ------------------ | | 645| 870| { } \ | | 646| 870| else \ | | 647| 870| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 870| } G_STMT_END | | ------------------ | | | | 882| 870|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 870] | | | | ------------------ | | ------------------ ------------------ 212| 870| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 870| G_STMT_START { \ | | ------------------ | | | | 874| 870|#define G_STMT_START do | | ------------------ | | 644| 870| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 870|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 870| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 870|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 870| int _g_boolean_var_; \ | | | | | | 1018| 1.74k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 870, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 870| _g_boolean_var_ = 1; \ | | | | | | 1020| 870| else \ | | | | | | 1021| 870| _g_boolean_var_ = 0; \ | | | | | | 1022| 870| _g_boolean_var_; \ | | | | | | 1023| 870|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 870, False: 0] | | | | ------------------ | | ------------------ | | 645| 870| { } \ | | 646| 870| else \ | | 647| 870| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 870| } G_STMT_END | | ------------------ | | | | 882| 870|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 870] | | | | ------------------ | | ------------------ ------------------ 213| 870| if (!fu_input_stream_read_safe(stream, buf, sizeof(buf), 0x0, offset, sizeof(buf), error)) ------------------ | Branch (213:6): [True: 10, False: 860] ------------------ 214| 10| return FALSE; ------------------ | | 814| 10|#define FALSE (0) ------------------ 215| 860| *value = fu_memread_uint32(buf, endian); 216| 860| return TRUE; ------------------ | | 818| 860|#define TRUE (!FALSE) | | ------------------ | | | | 814| 860|#define FALSE (0) | | ------------------ ------------------ 217| 870|} fu_input_stream_read_u64: 239| 878|{ 240| 878| guint8 buf[8] = {0}; 241| 878| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE); ------------------ | | 643| 878| G_STMT_START { \ | | ------------------ | | | | 874| 878|#define G_STMT_START do | | ------------------ | | 644| 878| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 878|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 878| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 878|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 878| int _g_boolean_var_; \ | | | | | | 1018| 6.14k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 878, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 878] | | | | | | | Branch (1018:8): [True: 0, False: 878] | | | | | | | Branch (1018:8): [True: 878, False: 0] | | | | | | ------------------ | | | | | | 1019| 878| _g_boolean_var_ = 1; \ | | | | | | 1020| 878| else \ | | | | | | 1021| 878| _g_boolean_var_ = 0; \ | | | | | | 1022| 878| _g_boolean_var_; \ | | | | | | 1023| 878|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 878, False: 0] | | | | ------------------ | | ------------------ | | 645| 878| { } \ | | 646| 878| else \ | | 647| 878| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 878| } G_STMT_END | | ------------------ | | | | 882| 878|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 878] | | | | ------------------ | | ------------------ ------------------ 242| 878| g_return_val_if_fail(value != NULL, FALSE); ------------------ | | 643| 878| G_STMT_START { \ | | ------------------ | | | | 874| 878|#define G_STMT_START do | | ------------------ | | 644| 878| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 878|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 878| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 878|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 878| int _g_boolean_var_; \ | | | | | | 1018| 878| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 878, False: 0] | | | | | | ------------------ | | | | | | 1019| 878| _g_boolean_var_ = 1; \ | | | | | | 1020| 878| else \ | | | | | | 1021| 878| _g_boolean_var_ = 0; \ | | | | | | 1022| 878| _g_boolean_var_; \ | | | | | | 1023| 878|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 878, False: 0] | | | | ------------------ | | ------------------ | | 645| 878| { } \ | | 646| 878| else \ | | 647| 878| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 878| } G_STMT_END | | ------------------ | | | | 882| 878|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 878] | | | | ------------------ | | ------------------ ------------------ 243| 878| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 878| G_STMT_START { \ | | ------------------ | | | | 874| 878|#define G_STMT_START do | | ------------------ | | 644| 878| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 878|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 878| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 878|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 878| int _g_boolean_var_; \ | | | | | | 1018| 1.75k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 878, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 878| _g_boolean_var_ = 1; \ | | | | | | 1020| 878| else \ | | | | | | 1021| 878| _g_boolean_var_ = 0; \ | | | | | | 1022| 878| _g_boolean_var_; \ | | | | | | 1023| 878|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 878, False: 0] | | | | ------------------ | | ------------------ | | 645| 878| { } \ | | 646| 878| else \ | | 647| 878| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 878| } G_STMT_END | | ------------------ | | | | 882| 878|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 878] | | | | ------------------ | | ------------------ ------------------ 244| 878| if (!fu_input_stream_read_safe(stream, buf, sizeof(buf), 0x0, offset, sizeof(buf), error)) ------------------ | Branch (244:6): [True: 9, False: 869] ------------------ 245| 9| return FALSE; ------------------ | | 814| 9|#define FALSE (0) ------------------ 246| 869| *value = fu_memread_uint64(buf, endian); 247| 869| return TRUE; ------------------ | | 818| 869|#define TRUE (!FALSE) | | ------------------ | | | | 814| 869|#define FALSE (0) | | ------------------ ------------------ 248| 878|} fu_input_stream_read_byte_array: 272| 5.70k|{ 273| 5.70k| guint8 tmp[0x8000]; /* nocheck:zero-init */ 274| 5.70k| g_autoptr(GByteArray) buf = g_byte_array_new(); ------------------ | | 1162| 5.70k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 5.70k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 275| 5.70k| g_autoptr(GError) error_local = NULL; ------------------ | | 1162| 5.70k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 5.70k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 276| | 277| 5.70k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), NULL); ------------------ | | 643| 5.70k| G_STMT_START { \ | | ------------------ | | | | 874| 5.70k|#define G_STMT_START do | | ------------------ | | 644| 5.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 5.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 5.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 5.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 5.70k| int _g_boolean_var_; \ | | | | | | 1018| 39.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5.70k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 5.70k] | | | | | | | Branch (1018:8): [True: 0, False: 5.70k] | | | | | | | Branch (1018:8): [True: 5.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 5.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 5.70k| else \ | | | | | | 1021| 5.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 5.70k| _g_boolean_var_; \ | | | | | | 1023| 5.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 5.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 5.70k| { } \ | | 646| 5.70k| else \ | | 647| 5.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 5.70k| } G_STMT_END | | ------------------ | | | | 882| 5.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 5.70k] | | | | ------------------ | | ------------------ ------------------ 278| 5.70k| g_return_val_if_fail(progress == NULL || FU_IS_PROGRESS(progress), NULL); ------------------ | | 643| 5.70k| G_STMT_START { \ | | ------------------ | | | | 874| 5.70k|#define G_STMT_START do | | ------------------ | | 644| 5.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 5.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 5.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 5.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 5.70k| int _g_boolean_var_; \ | | | | | | 1018| 11.4k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5.70k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 5.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 5.70k| else \ | | | | | | 1021| 5.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 5.70k| _g_boolean_var_; \ | | | | | | 1023| 5.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 5.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 5.70k| { } \ | | 646| 5.70k| else \ | | 647| 5.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 5.70k| } G_STMT_END | | ------------------ | | | | 882| 5.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 5.70k] | | | | ------------------ | | ------------------ ------------------ 279| 5.70k| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 5.70k| G_STMT_START { \ | | ------------------ | | | | 874| 5.70k|#define G_STMT_START do | | ------------------ | | 644| 5.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 5.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 5.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 5.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 5.70k| int _g_boolean_var_; \ | | | | | | 1018| 11.4k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5.70k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 5.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 5.70k| else \ | | | | | | 1021| 5.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 5.70k| _g_boolean_var_; \ | | | | | | 1023| 5.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 5.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 5.70k| { } \ | | 646| 5.70k| else \ | | 647| 5.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 5.70k| } G_STMT_END | | ------------------ | | | | 882| 5.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 5.70k] | | | | ------------------ | | ------------------ ------------------ 280| | 281| | /* this is invalid */ 282| 5.70k| if (count == 0) { ------------------ | Branch (282:6): [True: 3, False: 5.70k] ------------------ 283| 3| g_set_error_literal(error, 284| 3| FWUPD_ERROR, ------------------ | | 15| 3|#define FWUPD_ERROR fwupd_error_quark() ------------------ 285| 3| FWUPD_ERROR_NOT_SUPPORTED, 286| 3| "read size must be non-zero"); 287| 3| return NULL; 288| 3| } 289| | 290| | /* seek back to start */ 291| 5.70k| if (G_IS_SEEKABLE(stream) && g_seekable_can_seek(G_SEEKABLE(stream))) { ------------------ | | 34| 11.4k|#define G_IS_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_SEEKABLE)) | | ------------------ | | | | 497| 5.70k|#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type) (_G_TYPE_CIT ((instance), (g_type))) | | | | ------------------ | | | | | | 2313| 5.70k|# define _G_TYPE_CIT(ip, gt) (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 5.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 2314| 5.70k| GTypeInstance *__inst = (GTypeInstance*) ip; GType __t = gt; gboolean __r; \ | | | | | | 2315| 5.70k| if (!__inst) \ | | | | | | ------------------ | | | | | | | Branch (2315:7): [True: 0, False: 5.70k] | | | | | | ------------------ | | | | | | 2316| 5.70k| __r = FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | 2317| 5.70k| else if (__inst->g_class && __inst->g_class->g_type == __t) \ | | | | | | ------------------ | | | | | | | Branch (2317:12): [True: 5.70k, False: 0] | | | | | | | Branch (2317:31): [True: 0, False: 5.70k] | | | | | | ------------------ | | | | | | 2318| 5.70k| __r = TRUE; \ | | | | | | ------------------ | | | | | | | | 818| 0|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 0|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2319| 5.70k| else \ | | | | | | 2320| 5.70k| __r = g_type_check_instance_is_a (__inst, __t); \ | | | | | | 2321| 5.70k| __r; \ | | | | | | 2322| 5.70k|})) | | | | ------------------ | | ------------------ | | | Branch (34:36): [True: 5.70k, False: 0] | | ------------------ ------------------ if (G_IS_SEEKABLE(stream) && g_seekable_can_seek(G_SEEKABLE(stream))) { ------------------ | | 33| 5.70k|#define G_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable)) | | ------------------ | | | | 484| 5.70k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 5.70k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ | Branch (291:31): [True: 5.70k, False: 0] ------------------ 292| 5.70k| if (!g_seekable_seek(G_SEEKABLE(stream), offset, G_SEEK_SET, NULL, error)) ------------------ | | 33| 5.70k|#define G_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable)) | | ------------------ | | | | 484| 5.70k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 5.70k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ | Branch (292:7): [True: 0, False: 5.70k] ------------------ 293| 0| return NULL; 294| 5.70k| } 295| | 296| | /* read from stream in 32kB chunks */ 297| 6.16k| while (TRUE) { ------------------ | | 818| 6.16k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 6.16k|#define FALSE (0) | | ------------------ | | | Branch (818:14): [True: 6.16k, Folded] | | ------------------ ------------------ 298| 6.16k| gssize sz; 299| 6.16k| sz = g_input_stream_read(stream, 300| 6.16k| tmp, 301| 6.16k| MIN(count - buf->len, sizeof(tmp)), ------------------ | | 825| 6.16k|#define MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (825:21): [True: 6.16k, False: 0] | | ------------------ ------------------ 302| 6.16k| NULL, 303| 6.16k| &error_local); 304| 6.16k| if (sz == 0) ------------------ | Branch (304:7): [True: 518, False: 5.64k] ------------------ 305| 518| break; 306| 5.64k| if (sz < 0) { ------------------ | Branch (306:7): [True: 0, False: 5.64k] ------------------ 307| 0| g_set_error_literal(error, 308| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 309| 0| FWUPD_ERROR_INVALID_FILE, 310| 0| error_local->message); 311| 0| return NULL; 312| 0| } 313| | 314| | /* update progress */ 315| 5.64k| if (progress != NULL) ------------------ | Branch (315:7): [True: 0, False: 5.64k] ------------------ 316| 0| fu_progress_set_percentage_full(progress, buf->len, count); 317| | 318| 5.64k| g_byte_array_append(buf, tmp, sz); 319| 5.64k| if (buf->len >= count) ------------------ | Branch (319:7): [True: 5.18k, False: 458] ------------------ 320| 5.18k| break; 321| 5.64k| } 322| | 323| | /* no data was read */ 324| 5.70k| if (buf->len == 0) { ------------------ | Branch (324:6): [True: 60, False: 5.64k] ------------------ 325| 60| g_set_error_literal(error, 326| 60| FWUPD_ERROR, ------------------ | | 15| 60|#define FWUPD_ERROR fwupd_error_quark() ------------------ 327| 60| FWUPD_ERROR_INVALID_FILE, 328| 60| "no data could be read"); 329| 60| return NULL; 330| 60| } 331| | 332| | /* success */ 333| 5.64k| return g_steal_pointer(&buf); ------------------ | | 222| 5.64k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 334| 5.70k|} fu_input_stream_read_bytes: 358| 2.94k|{ 359| 2.94k| g_autoptr(GByteArray) buf = NULL; ------------------ | | 1162| 2.94k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 2.94k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 360| 2.94k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), NULL); ------------------ | | 643| 2.94k| G_STMT_START { \ | | ------------------ | | | | 874| 2.94k|#define G_STMT_START do | | ------------------ | | 644| 2.94k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.94k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.94k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.94k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.94k| int _g_boolean_var_; \ | | | | | | 1018| 20.6k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.94k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 2.94k] | | | | | | | Branch (1018:8): [True: 0, False: 2.94k] | | | | | | | Branch (1018:8): [True: 2.94k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.94k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.94k| else \ | | | | | | 1021| 2.94k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.94k| _g_boolean_var_; \ | | | | | | 1023| 2.94k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.94k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.94k| { } \ | | 646| 2.94k| else \ | | 647| 2.94k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.94k| } G_STMT_END | | ------------------ | | | | 882| 2.94k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.94k] | | | | ------------------ | | ------------------ ------------------ 361| 2.94k| g_return_val_if_fail(progress == NULL || FU_IS_PROGRESS(progress), NULL); ------------------ | | 643| 2.94k| G_STMT_START { \ | | ------------------ | | | | 874| 2.94k|#define G_STMT_START do | | ------------------ | | 644| 2.94k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.94k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.94k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.94k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.94k| int _g_boolean_var_; \ | | | | | | 1018| 5.88k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.94k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.94k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.94k| else \ | | | | | | 1021| 2.94k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.94k| _g_boolean_var_; \ | | | | | | 1023| 2.94k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.94k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.94k| { } \ | | 646| 2.94k| else \ | | 647| 2.94k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.94k| } G_STMT_END | | ------------------ | | | | 882| 2.94k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.94k] | | | | ------------------ | | ------------------ ------------------ 362| 2.94k| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 2.94k| G_STMT_START { \ | | ------------------ | | | | 874| 2.94k|#define G_STMT_START do | | ------------------ | | 644| 2.94k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.94k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.94k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.94k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.94k| int _g_boolean_var_; \ | | | | | | 1018| 5.88k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.94k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.94k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.94k| else \ | | | | | | 1021| 2.94k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.94k| _g_boolean_var_; \ | | | | | | 1023| 2.94k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.94k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.94k| { } \ | | 646| 2.94k| else \ | | 647| 2.94k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.94k| } G_STMT_END | | ------------------ | | | | 882| 2.94k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.94k] | | | | ------------------ | | ------------------ ------------------ 363| 2.94k| buf = fu_input_stream_read_byte_array(stream, offset, count, progress, error); 364| 2.94k| if (buf == NULL) ------------------ | Branch (364:6): [True: 32, False: 2.91k] ------------------ 365| 32| return NULL; 366| 2.91k| return g_byte_array_free_to_bytes(g_steal_pointer(&buf)); ------------------ | | 222| 2.91k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 367| 2.94k|} fu_input_stream_read_string: 384| 2.76k|{ 385| 2.76k| g_autoptr(GByteArray) buf = NULL; ------------------ | | 1162| 2.76k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 2.76k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 386| | 387| 2.76k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), NULL); ------------------ | | 643| 2.76k| G_STMT_START { \ | | ------------------ | | | | 874| 2.76k|#define G_STMT_START do | | ------------------ | | 644| 2.76k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.76k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.76k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.76k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.76k| int _g_boolean_var_; \ | | | | | | 1018| 19.3k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.76k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 2.76k] | | | | | | | Branch (1018:8): [True: 0, False: 2.76k] | | | | | | | Branch (1018:8): [True: 2.76k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.76k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.76k| else \ | | | | | | 1021| 2.76k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.76k| _g_boolean_var_; \ | | | | | | 1023| 2.76k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.76k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.76k| { } \ | | 646| 2.76k| else \ | | 647| 2.76k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.76k| } G_STMT_END | | ------------------ | | | | 882| 2.76k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.76k] | | | | ------------------ | | ------------------ ------------------ 388| 2.76k| g_return_val_if_fail(error == NULL || *error == NULL, NULL); ------------------ | | 643| 2.76k| G_STMT_START { \ | | ------------------ | | | | 874| 2.76k|#define G_STMT_START do | | ------------------ | | 644| 2.76k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.76k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.76k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.76k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.76k| int _g_boolean_var_; \ | | | | | | 1018| 5.52k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.76k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.76k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.76k| else \ | | | | | | 1021| 2.76k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.76k| _g_boolean_var_; \ | | | | | | 1023| 2.76k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.76k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.76k| { } \ | | 646| 2.76k| else \ | | 647| 2.76k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.76k| } G_STMT_END | | ------------------ | | | | 882| 2.76k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.76k] | | | | ------------------ | | ------------------ ------------------ 389| | 390| 2.76k| buf = fu_input_stream_read_byte_array(stream, offset, count, NULL, error); 391| 2.76k| if (buf == NULL) ------------------ | Branch (391:6): [True: 31, False: 2.73k] ------------------ 392| 31| return NULL; 393| 2.73k| if (!g_utf8_validate_len((const gchar *)buf->data, buf->len, NULL)) { ------------------ | Branch (393:6): [True: 151, False: 2.58k] ------------------ 394| 151| g_set_error_literal(error, 395| 151| FWUPD_ERROR, ------------------ | | 15| 151|#define FWUPD_ERROR fwupd_error_quark() ------------------ 396| 151| FWUPD_ERROR_NOT_SUPPORTED, 397| 151| "non UTF-8 string"); 398| 151| return NULL; 399| 151| } 400| 2.58k| return g_strndup((const gchar *)buf->data, buf->len); 401| 2.73k|} fu_input_stream_size: 419| 3.85k|{ 420| 3.85k| g_return_val_if_fail(G_IS_INPUT_STREAM(stream), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 26.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 421| 3.85k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuInputStream" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 422| | 423| | /* streaming from unseekable stream */ 424| 3.85k| if (!G_IS_SEEKABLE(stream) || !g_seekable_can_seek(G_SEEKABLE(stream))) { ------------------ | | 34| 7.70k|#define G_IS_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_TYPE_SEEKABLE)) | | ------------------ | | | | 497| 3.85k|#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type) (_G_TYPE_CIT ((instance), (g_type))) | | | | ------------------ | | | | | | 2313| 3.85k|# define _G_TYPE_CIT(ip, gt) (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 2314| 3.85k| GTypeInstance *__inst = (GTypeInstance*) ip; GType __t = gt; gboolean __r; \ | | | | | | 2315| 3.85k| if (!__inst) \ | | | | | | ------------------ | | | | | | | Branch (2315:7): [True: 0, False: 3.85k] | | | | | | ------------------ | | | | | | 2316| 3.85k| __r = FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | 2317| 3.85k| else if (__inst->g_class && __inst->g_class->g_type == __t) \ | | | | | | ------------------ | | | | | | | Branch (2317:12): [True: 3.85k, False: 0] | | | | | | | Branch (2317:31): [True: 0, False: 3.85k] | | | | | | ------------------ | | | | | | 2318| 3.85k| __r = TRUE; \ | | | | | | ------------------ | | | | | | | | 818| 0|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 0|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2319| 3.85k| else \ | | | | | | 2320| 3.85k| __r = g_type_check_instance_is_a (__inst, __t); \ | | | | | | 2321| 3.85k| __r; \ | | | | | | 2322| 3.85k|})) | | | | ------------------ | | ------------------ ------------------ if (!G_IS_SEEKABLE(stream) || !g_seekable_can_seek(G_SEEKABLE(stream))) { ------------------ | | 33| 3.85k|#define G_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ | Branch (424:6): [True: 0, False: 3.85k] | Branch (424:32): [True: 0, False: 3.85k] ------------------ 425| 0| if (val != NULL) ------------------ | Branch (425:7): [True: 0, False: 0] ------------------ 426| 0| *val = G_MAXSIZE; ------------------ | | 84| 0|#define G_MAXSIZE G_MAXULONG | | ------------------ | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | ------------------ ------------------ 427| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 428| 0| } 429| | 430| 3.85k| if (!g_seekable_seek(G_SEEKABLE(stream), 0, G_SEEK_END, NULL, error)) { ------------------ | | 33| 3.85k|#define G_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ | Branch (430:6): [True: 0, False: 3.85k] ------------------ 431| 0| g_prefix_error_literal(error, "seek to end: "); ------------------ | | 11| 0|#define g_prefix_error_literal g_prefix_error ------------------ 432| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 433| 0| } 434| 3.85k| if (val != NULL) ------------------ | Branch (434:6): [True: 3.85k, False: 0] ------------------ 435| 3.85k| *val = g_seekable_tell(G_SEEKABLE(stream)); ------------------ | | 33| 3.85k|#define G_SEEKABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_TYPE_SEEKABLE, GSeekable)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 436| | 437| | /* success */ 438| 3.85k| return TRUE; ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 439| 3.85k|} fu_memwrite_uint16: 29| 723|{ 30| 723| guint16 val_hw; 31| 723| switch (endian) { 32| 723| case G_BIG_ENDIAN: ------------------ | | 185| 723|#define G_BIG_ENDIAN 4321 ------------------ | Branch (32:2): [True: 723, False: 0] ------------------ 33| 723| val_hw = GUINT16_TO_BE(val_native); /* nocheck:blocked */ ------------------ | | 162| 723|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | ------------------ | | | | 351| 723|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | ------------------ | | | | | | 191| 723|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | 192| 723| (guint16) ((guint16) (val) >> 8) | \ | | | | | | 193| 723| (guint16) ((guint16) (val) << 8))) | | | | ------------------ | | ------------------ ------------------ 34| 723| break; 35| 0| case G_LITTLE_ENDIAN: ------------------ | | 184| 0|#define G_LITTLE_ENDIAN 1234 ------------------ | Branch (35:2): [True: 0, False: 723] ------------------ 36| 0| val_hw = GUINT16_TO_LE(val_native); /* nocheck:blocked */ ------------------ | | 160| 0|#define GUINT16_TO_LE(val) ((guint16) (val)) ------------------ 37| 0| break; 38| 0| default: ------------------ | Branch (38:2): [True: 0, False: 723] ------------------ 39| 0| val_hw = val_native; 40| 0| break; 41| 723| } 42| 723| memcpy(buf, &val_hw, sizeof(val_hw)); /* nocheck:blocked */ 43| 723|} fu_memwrite_uint32: 85| 274|{ 86| 274| guint32 val_hw; 87| 274| switch (endian) { 88| 274| case G_BIG_ENDIAN: ------------------ | | 185| 274|#define G_BIG_ENDIAN 4321 ------------------ | Branch (88:2): [True: 274, False: 0] ------------------ 89| 274| val_hw = GUINT32_TO_BE(val_native); /* nocheck:blocked */ ------------------ | | 167| 274|#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val)) | | ------------------ | | | | 353| 274|# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86_64 (val)) | | | | ------------------ | | | | | | 331| 274| (G_GNUC_EXTENSION \ | | | | | | ------------------ | | | | | | | | 54| 274|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 332| 274| ({ guint32 __v, __x = ((guint32) (val)); \ | | | | | | 333| 274| if (__builtin_constant_p (__x)) \ | | | | | | ------------------ | | | | | | | Branch (333:10): [True: 0, False: 274] | | | | | | ------------------ | | | | | | 334| 274| __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); \ | | | | | | ------------------ | | | | | | | | 195| 0|#define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \ | | | | | | | | 196| 0| (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \ | | | | | | | | 197| 0| (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | \ | | | | | | | | 198| 0| (((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | \ | | | | | | | | 199| 0| (((guint32) (val) & (guint32) 0xff000000U) >> 24))) | | | | | | ------------------ | | | | | | 335| 274| else \ | | | | | | 336| 274| __asm__ ("bswapl %0" \ | | | | | | 337| 274| : "=r" (__v) \ | | | | | | 338| 274| : "0" (__x)); \ | | | | | | 339| 274| __v; })) | | | | ------------------ | | ------------------ ------------------ 90| 274| break; 91| 0| case G_LITTLE_ENDIAN: ------------------ | | 184| 0|#define G_LITTLE_ENDIAN 1234 ------------------ | Branch (91:2): [True: 0, False: 274] ------------------ 92| 0| val_hw = GUINT32_TO_LE(val_native); /* nocheck:blocked */ ------------------ | | 165| 0|#define GUINT32_TO_LE(val) ((guint32) (val)) ------------------ 93| 0| break; 94| 0| default: ------------------ | Branch (94:2): [True: 0, False: 274] ------------------ 95| 0| val_hw = val_native; 96| 0| break; 97| 274| } 98| 274| memcpy(buf, &val_hw, sizeof(val_hw)); /* nocheck:blocked */ 99| 274|} fu_memwrite_uint64: 113| 69|{ 114| 69| guint64 val_hw; 115| 69| switch (endian) { 116| 69| case G_BIG_ENDIAN: ------------------ | | 185| 69|#define G_BIG_ENDIAN 4321 ------------------ | Branch (116:2): [True: 69, False: 0] ------------------ 117| 69| val_hw = GUINT64_TO_BE(val_native); /* nocheck:blocked */ ------------------ | | 172| 69|#define GUINT64_TO_BE(val) (GUINT64_SWAP_LE_BE (val)) | | ------------------ | | | | 356| 69|# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86_64 (val)) | | | | ------------------ | | | | | | 341| 69| (G_GNUC_EXTENSION \ | | | | | | ------------------ | | | | | | | | 54| 69|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 342| 69| ({ guint64 __v, __x = ((guint64) (val)); \ | | | | | | 343| 69| if (__builtin_constant_p (__x)) \ | | | | | | ------------------ | | | | | | | Branch (343:9): [True: 0, False: 69] | | | | | | ------------------ | | | | | | 344| 69| __v = GUINT64_SWAP_LE_BE_CONSTANT (__x); \ | | | | | | ------------------ | | | | | | | | 201| 0|#define GUINT64_SWAP_LE_BE_CONSTANT(val) ((guint64) ( \ | | | | | | | | 202| 0| (((guint64) (val) & \ | | | | | | | | 203| 0| (guint64) G_GINT64_CONSTANT (0x00000000000000ffU)) << 56) | \ | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | | | 204| 0| (((guint64) (val) & \ | | | | | | | | 205| 0| (guint64) G_GINT64_CONSTANT (0x000000000000ff00U)) << 40) | \ | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | | | 206| 0| (((guint64) (val) & \ | | | | | | | | 207| 0| (guint64) G_GINT64_CONSTANT (0x0000000000ff0000U)) << 24) | \ | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | | | 208| 0| (((guint64) (val) & \ | | | | | | | | 209| 0| (guint64) G_GINT64_CONSTANT (0x00000000ff000000U)) << 8) | \ | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | | | 210| 0| (((guint64) (val) & \ | | | | | | | | 211| 0| (guint64) G_GINT64_CONSTANT (0x000000ff00000000U)) >> 8) | \ | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | | | 212| 0| (((guint64) (val) & \ | | | | | | | | 213| 0| (guint64) G_GINT64_CONSTANT (0x0000ff0000000000U)) >> 24) | \ | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | | | 214| 0| (((guint64) (val) & \ | | | | | | | | 215| 0| (guint64) G_GINT64_CONSTANT (0x00ff000000000000U)) >> 40) | \ | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | | | 216| 0| (((guint64) (val) & \ | | | | | | | | 217| 0| (guint64) G_GINT64_CONSTANT (0xff00000000000000U)) >> 56))) | | | | | | | | ------------------ | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 345| 69| else \ | | | | | | 346| 69| __asm__ ("bswapq %0" \ | | | | | | 347| 69| : "=r" (__v) \ | | | | | | 348| 69| : "0" (__x)); \ | | | | | | 349| 69| __v; })) | | | | ------------------ | | ------------------ ------------------ 118| 69| break; 119| 0| case G_LITTLE_ENDIAN: ------------------ | | 184| 0|#define G_LITTLE_ENDIAN 1234 ------------------ | Branch (119:2): [True: 0, False: 69] ------------------ 120| 0| val_hw = GUINT64_TO_LE(val_native); /* nocheck:blocked */ ------------------ | | 170| 0|#define GUINT64_TO_LE(val) ((guint64) (val)) ------------------ 121| 0| break; 122| 0| default: ------------------ | Branch (122:2): [True: 0, False: 69] ------------------ 123| 0| val_hw = val_native; 124| 0| break; 125| 69| } 126| 69| memcpy(buf, &val_hw, sizeof(val_hw)); /* nocheck:blocked */ 127| 69|} fu_memread_uint16: 142| 919|{ 143| 919| guint16 val_hw, val_native; 144| 919| memcpy(&val_hw, buf, sizeof(val_hw)); /* nocheck:blocked */ 145| 919| switch (endian) { 146| 919| case G_BIG_ENDIAN: ------------------ | | 185| 919|#define G_BIG_ENDIAN 4321 ------------------ | Branch (146:2): [True: 919, False: 0] ------------------ 147| 919| val_native = GUINT16_FROM_BE(val_hw); /* nocheck:blocked */ ------------------ | | 388| 919|#define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val)) | | ------------------ | | | | 162| 919|#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 351| 919|# define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val)) | | | | | | ------------------ | | | | | | | | 191| 919|#define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \ | | | | | | | | 192| 919| (guint16) ((guint16) (val) >> 8) | \ | | | | | | | | 193| 919| (guint16) ((guint16) (val) << 8))) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 148| 919| break; 149| 0| case G_LITTLE_ENDIAN: ------------------ | | 184| 0|#define G_LITTLE_ENDIAN 1234 ------------------ | Branch (149:2): [True: 0, False: 919] ------------------ 150| 0| val_native = GUINT16_FROM_LE(val_hw); /* nocheck:blocked */ ------------------ | | 386| 0|#define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val)) | | ------------------ | | | | 160| 0|#define GUINT16_TO_LE(val) ((guint16) (val)) | | ------------------ ------------------ 151| 0| break; 152| 0| default: ------------------ | Branch (152:2): [True: 0, False: 919] ------------------ 153| 0| val_native = val_hw; 154| 0| break; 155| 919| } 156| 919| return val_native; 157| 919|} fu_memread_uint32: 204| 860|{ 205| 860| guint32 val_hw, val_native; 206| 860| memcpy(&val_hw, buf, sizeof(val_hw)); /* nocheck:blocked */ 207| 860| switch (endian) { 208| 860| case G_BIG_ENDIAN: ------------------ | | 185| 860|#define G_BIG_ENDIAN 4321 ------------------ | Branch (208:2): [True: 860, False: 0] ------------------ 209| 860| val_native = GUINT32_FROM_BE(val_hw); /* nocheck:blocked */ ------------------ | | 392| 860|#define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val)) | | ------------------ | | | | 167| 860|#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 353| 860|# define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86_64 (val)) | | | | | | ------------------ | | | | | | | | 331| 860| (G_GNUC_EXTENSION \ | | | | | | | | ------------------ | | | | | | | | | | 54| 860|#define G_GNUC_EXTENSION __extension__ | | | | | | | | ------------------ | | | | | | | | 332| 860| ({ guint32 __v, __x = ((guint32) (val)); \ | | | | | | | | 333| 860| if (__builtin_constant_p (__x)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (333:10): [True: 0, False: 860] | | | | | | | | ------------------ | | | | | | | | 334| 860| __v = GUINT32_SWAP_LE_BE_CONSTANT (__x); \ | | | | | | | | ------------------ | | | | | | | | | | 195| 0|#define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \ | | | | | | | | | | 196| 0| (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \ | | | | | | | | | | 197| 0| (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | \ | | | | | | | | | | 198| 0| (((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | \ | | | | | | | | | | 199| 0| (((guint32) (val) & (guint32) 0xff000000U) >> 24))) | | | | | | | | ------------------ | | | | | | | | 335| 860| else \ | | | | | | | | 336| 860| __asm__ ("bswapl %0" \ | | | | | | | | 337| 860| : "=r" (__v) \ | | | | | | | | 338| 860| : "0" (__x)); \ | | | | | | | | 339| 860| __v; })) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 210| 860| break; 211| 0| case G_LITTLE_ENDIAN: ------------------ | | 184| 0|#define G_LITTLE_ENDIAN 1234 ------------------ | Branch (211:2): [True: 0, False: 860] ------------------ 212| 0| val_native = GUINT32_FROM_LE(val_hw); /* nocheck:blocked */ ------------------ | | 390| 0|#define GUINT32_FROM_LE(val) (GUINT32_TO_LE (val)) | | ------------------ | | | | 165| 0|#define GUINT32_TO_LE(val) ((guint32) (val)) | | ------------------ ------------------ 213| 0| break; 214| 0| default: ------------------ | Branch (214:2): [True: 0, False: 860] ------------------ 215| 0| val_native = val_hw; 216| 0| break; 217| 860| } 218| 860| return val_native; 219| 860|} fu_memread_uint64: 234| 869|{ 235| 869| guint64 val_hw, val_native; 236| 869| memcpy(&val_hw, buf, sizeof(val_hw)); /* nocheck:blocked */ 237| 869| switch (endian) { 238| 869| case G_BIG_ENDIAN: ------------------ | | 185| 869|#define G_BIG_ENDIAN 4321 ------------------ | Branch (238:2): [True: 869, False: 0] ------------------ 239| 869| val_native = GUINT64_FROM_BE(val_hw); /* nocheck:blocked */ ------------------ | | 397| 869|#define GUINT64_FROM_BE(val) (GUINT64_TO_BE (val)) | | ------------------ | | | | 172| 869|#define GUINT64_TO_BE(val) (GUINT64_SWAP_LE_BE (val)) | | | | ------------------ | | | | | | 356| 869|# define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86_64 (val)) | | | | | | ------------------ | | | | | | | | 341| 869| (G_GNUC_EXTENSION \ | | | | | | | | ------------------ | | | | | | | | | | 54| 869|#define G_GNUC_EXTENSION __extension__ | | | | | | | | ------------------ | | | | | | | | 342| 869| ({ guint64 __v, __x = ((guint64) (val)); \ | | | | | | | | 343| 869| if (__builtin_constant_p (__x)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (343:9): [True: 0, False: 869] | | | | | | | | ------------------ | | | | | | | | 344| 869| __v = GUINT64_SWAP_LE_BE_CONSTANT (__x); \ | | | | | | | | ------------------ | | | | | | | | | | 201| 0|#define GUINT64_SWAP_LE_BE_CONSTANT(val) ((guint64) ( \ | | | | | | | | | | 202| 0| (((guint64) (val) & \ | | | | | | | | | | 203| 0| (guint64) G_GINT64_CONSTANT (0x00000000000000ffU)) << 56) | \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | | | 204| 0| (((guint64) (val) & \ | | | | | | | | | | 205| 0| (guint64) G_GINT64_CONSTANT (0x000000000000ff00U)) << 40) | \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | | | 206| 0| (((guint64) (val) & \ | | | | | | | | | | 207| 0| (guint64) G_GINT64_CONSTANT (0x0000000000ff0000U)) << 24) | \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | | | 208| 0| (((guint64) (val) & \ | | | | | | | | | | 209| 0| (guint64) G_GINT64_CONSTANT (0x00000000ff000000U)) << 8) | \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | | | 210| 0| (((guint64) (val) & \ | | | | | | | | | | 211| 0| (guint64) G_GINT64_CONSTANT (0x000000ff00000000U)) >> 8) | \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | | | 212| 0| (((guint64) (val) & \ | | | | | | | | | | 213| 0| (guint64) G_GINT64_CONSTANT (0x0000ff0000000000U)) >> 24) | \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | | | 214| 0| (((guint64) (val) & \ | | | | | | | | | | 215| 0| (guint64) G_GINT64_CONSTANT (0x00ff000000000000U)) >> 40) | \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | | | 216| 0| (((guint64) (val) & \ | | | | | | | | | | 217| 0| (guint64) G_GINT64_CONSTANT (0xff00000000000000U)) >> 56))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 64| 0|#define G_GINT64_CONSTANT(val) (val##L) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 345| 869| else \ | | | | | | | | 346| 869| __asm__ ("bswapq %0" \ | | | | | | | | 347| 869| : "=r" (__v) \ | | | | | | | | 348| 869| : "0" (__x)); \ | | | | | | | | 349| 869| __v; })) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 240| 869| break; 241| 0| case G_LITTLE_ENDIAN: ------------------ | | 184| 0|#define G_LITTLE_ENDIAN 1234 ------------------ | Branch (241:2): [True: 0, False: 869] ------------------ 242| 0| val_native = GUINT64_FROM_LE(val_hw); /* nocheck:blocked */ ------------------ | | 395| 0|#define GUINT64_FROM_LE(val) (GUINT64_TO_LE (val)) | | ------------------ | | | | 170| 0|#define GUINT64_TO_LE(val) ((guint64) (val)) | | ------------------ ------------------ 243| 0| break; 244| 0| default: ------------------ | Branch (244:2): [True: 0, False: 869] ------------------ 245| 0| val_native = val_hw; 246| 0| break; 247| 869| } 248| 869| return val_native; 249| 869|} fu_memchk_write: 380| 114k|{ 381| 114k| g_return_val_if_fail(error == NULL || *error == NULL, FALSE); ------------------ | | 643| 114k| G_STMT_START { \ | | ------------------ | | | | 874| 114k|#define G_STMT_START do | | ------------------ | | 644| 114k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 114k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 114k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 114k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 114k| int _g_boolean_var_; \ | | | | | | 1018| 228k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 114k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 114k| _g_boolean_var_ = 1; \ | | | | | | 1020| 114k| else \ | | | | | | 1021| 114k| _g_boolean_var_ = 0; \ | | | | | | 1022| 114k| _g_boolean_var_; \ | | | | | | 1023| 114k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 114k, False: 0] | | | | ------------------ | | ------------------ | | 645| 114k| { } \ | | 646| 114k| else \ | | 647| 114k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | ------------------ | | | | 7| 0|#define G_LOG_DOMAIN "FuCommon" | | ------------------ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 114k| } G_STMT_END | | ------------------ | | | | 882| 114k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 114k] | | | | ------------------ | | ------------------ ------------------ 382| 114k| if (n == 0) ------------------ | Branch (382:6): [True: 0, False: 114k] ------------------ 383| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 384| 114k| if (n > bufsz) { ------------------ | Branch (384:6): [True: 0, False: 114k] ------------------ 385| 0| g_set_error(error, 386| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 387| 0| FWUPD_ERROR_WRITE, 388| 0| "attempted to write 0x%02x bytes to buffer of 0x%02x", 389| 0| (guint)n, 390| 0| (guint)bufsz); 391| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 392| 0| } 393| 114k| if (fu_size_checked_add(offset, n) == G_MAXSIZE) { ------------------ | | 84| 114k|#define G_MAXSIZE G_MAXULONG | | ------------------ | | | | 38| 114k|#define G_MAXULONG ULONG_MAX | | ------------------ ------------------ | Branch (393:6): [True: 0, False: 114k] ------------------ 394| 0| g_set_error(error, 395| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 396| 0| FWUPD_ERROR_WRITE, 397| 0| "offset 0x%02x + 0x%02x overflowed", 398| 0| (guint)offset, 399| 0| (guint)n); 400| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 401| 0| } 402| 114k| if (offset > bufsz || n + offset > bufsz) { ------------------ | Branch (402:6): [True: 0, False: 114k] | Branch (402:24): [True: 0, False: 114k] ------------------ 403| 0| g_set_error(error, 404| 0| FWUPD_ERROR, ------------------ | | 15| 0|#define FWUPD_ERROR fwupd_error_quark() ------------------ 405| 0| FWUPD_ERROR_WRITE, 406| 0| "attempted to write 0x%02x bytes at offset 0x%02x to buffer of 0x%02x", 407| 0| (guint)n, 408| 0| (guint)offset, 409| 0| (guint)bufsz); 410| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 411| 0| } 412| 114k| return TRUE; ------------------ | | 818| 114k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 114k|#define FALSE (0) | | ------------------ ------------------ 413| 114k|} g_dbus_error_register_error: 366| 22|{ 367| 22| gboolean ret; 368| 22| QuarkCodePair pair; 369| 22| RegisteredError *re; 370| | 371| 22| g_return_val_if_fail (dbus_error_name != NULL, FALSE); ------------------ | | 643| 22| G_STMT_START { \ | | ------------------ | | | | 874| 22|#define G_STMT_START do | | ------------------ | | 644| 22| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 22|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 22| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 22|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 22| int _g_boolean_var_; \ | | | | | | 1018| 22| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 22, False: 0] | | | | | | ------------------ | | | | | | 1019| 22| _g_boolean_var_ = 1; \ | | | | | | 1020| 22| else \ | | | | | | 1021| 22| _g_boolean_var_ = 0; \ | | | | | | 1022| 22| _g_boolean_var_; \ | | | | | | 1023| 22|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 22, False: 0] | | | | ------------------ | | ------------------ | | 645| 22| { } \ | | 646| 22| else \ | | 647| 22| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 22| } G_STMT_END | | ------------------ | | | | 882| 22|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 22] | | | | ------------------ | | ------------------ ------------------ 372| | 373| 22| ret = FALSE; ------------------ | | 814| 22|#define FALSE (0) ------------------ 374| | 375| 22| G_LOCK (error_lock); ------------------ | | 135| 22|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 22|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 376| | 377| 22| if (quark_code_pair_to_re == NULL) ------------------ | Branch (377:7): [True: 1, False: 21] ------------------ 378| 1| { 379| 1| g_assert (dbus_error_name_to_re == NULL); /* check invariant */ ------------------ | | 231| 1|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 232| 1| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 233| 1| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 380| 1| quark_code_pair_to_re = g_hash_table_new ((GHashFunc) quark_code_pair_hash_func, 381| 1| (GEqualFunc) quark_code_pair_equal_func); 382| 1| dbus_error_name_to_re = g_hash_table_new_full (g_str_hash, 383| 1| g_str_equal, 384| 1| NULL, 385| 1| (GDestroyNotify) registered_error_free); 386| 1| } 387| | 388| 22| if (g_hash_table_lookup (dbus_error_name_to_re, dbus_error_name) != NULL) ------------------ | Branch (388:7): [True: 0, False: 22] ------------------ 389| 0| goto out; 390| | 391| 22| pair.error_domain = error_domain; 392| 22| pair.error_code = error_code; 393| | 394| 22| if (g_hash_table_lookup (quark_code_pair_to_re, &pair) != NULL) ------------------ | Branch (394:7): [True: 0, False: 22] ------------------ 395| 0| goto out; 396| | 397| 22| re = g_new0 (RegisteredError, 1); ------------------ | | 307| 22|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 22| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 22|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 22| gsize __n = (gsize) (n_structs); \ | | | | 237| 22| gsize __s = sizeof (struct_type); \ | | | | 238| 22| gpointer __p; \ | | | | 239| 22| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 22] | | | | ------------------ | | | | 240| 22| __p = g_##func (__n); \ | | | | 241| 22| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 22, False: 0] | | | | ------------------ | | | | 242| 22| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 22|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 22|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 22] | | | | | Branch (242:26): [True: 22, False: 0] | | | | ------------------ | | | | 243| 22| __p = g_##func (__n * __s); \ | | | | 244| 22| else \ | | | | 245| 22| __p = g_##func##_n (__n, __s); \ | | | | 246| 22| __p; \ | | | | 247| 22| })) | | ------------------ ------------------ 398| 22| re->pair = pair; 399| 22| re->dbus_error_name = g_strdup (dbus_error_name); 400| | 401| 22| g_hash_table_insert (quark_code_pair_to_re, &(re->pair), re); 402| 22| g_hash_table_insert (dbus_error_name_to_re, re->dbus_error_name, re); 403| | 404| 22| ret = TRUE; ------------------ | | 818| 22|#define TRUE (!FALSE) | | ------------------ | | | | 814| 22|#define FALSE (0) | | ------------------ ------------------ 405| | 406| 22| out: 407| 22| G_UNLOCK (error_lock); ------------------ | | 136| 22|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 22|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 408| 22| return ret; 409| 22|} gdbuserror.c:quark_code_pair_hash_func: 311| 44|{ 312| 44| gint val; 313| 44| val = pair->error_domain + pair->error_code; 314| 44| return g_int_hash (&val); 315| 44|} g_input_stream_read: 166| 120k|{ 167| 120k| GInputStreamClass *class; 168| 120k| gssize res; 169| | 170| 120k| g_return_val_if_fail (G_IS_INPUT_STREAM (stream), -1); ------------------ | | 643| 120k| G_STMT_START { \ | | ------------------ | | | | 874| 120k|#define G_STMT_START do | | ------------------ | | 644| 120k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 120k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 120k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 120k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 120k| int _g_boolean_var_; \ | | | | | | 1018| 843k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 120k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 120k] | | | | | | | Branch (1018:8): [True: 0, False: 120k] | | | | | | | Branch (1018:8): [True: 120k, False: 0] | | | | | | ------------------ | | | | | | 1019| 120k| _g_boolean_var_ = 1; \ | | | | | | 1020| 120k| else \ | | | | | | 1021| 120k| _g_boolean_var_ = 0; \ | | | | | | 1022| 120k| _g_boolean_var_; \ | | | | | | 1023| 120k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 120k, False: 0] | | | | ------------------ | | ------------------ | | 645| 120k| { } \ | | 646| 120k| else \ | | 647| 120k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 120k| } G_STMT_END | | ------------------ | | | | 882| 120k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 120k] | | | | ------------------ | | ------------------ ------------------ 171| 120k| g_return_val_if_fail (buffer != NULL, 0); ------------------ | | 643| 120k| G_STMT_START { \ | | ------------------ | | | | 874| 120k|#define G_STMT_START do | | ------------------ | | 644| 120k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 120k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 120k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 120k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 120k| int _g_boolean_var_; \ | | | | | | 1018| 120k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 120k, False: 0] | | | | | | ------------------ | | | | | | 1019| 120k| _g_boolean_var_ = 1; \ | | | | | | 1020| 120k| else \ | | | | | | 1021| 120k| _g_boolean_var_ = 0; \ | | | | | | 1022| 120k| _g_boolean_var_; \ | | | | | | 1023| 120k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 120k, False: 0] | | | | ------------------ | | ------------------ | | 645| 120k| { } \ | | 646| 120k| else \ | | 647| 120k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 120k| } G_STMT_END | | ------------------ | | | | 882| 120k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 120k] | | | | ------------------ | | ------------------ ------------------ 172| | 173| 120k| if (count == 0) ------------------ | Branch (173:7): [True: 0, False: 120k] ------------------ 174| 0| return 0; 175| | 176| 120k| if (((gssize) count) < 0) ------------------ | Branch (176:7): [True: 0, False: 120k] ------------------ 177| 0| { 178| 0| g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, ------------------ | | 39| 0|#define G_IO_ERROR g_io_error_quark() ------------------ 179| 0| _("Too large count value passed to %s"), G_STRFUNC); ------------------ | | 17| 0|#define _(String) glib_gettext(String) ------------------ _("Too large count value passed to %s"), G_STRFUNC); ------------------ | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) ------------------ 180| 0| return -1; 181| 0| } 182| | 183| 120k| class = G_INPUT_STREAM_GET_CLASS (stream); ------------------ | | 37| 120k|#define G_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_INPUT_STREAM, GInputStreamClass)) | | ------------------ | | | | 527| 120k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 120k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ 184| | 185| 120k| if (class->read_fn == NULL) ------------------ | Branch (185:7): [True: 0, False: 120k] ------------------ 186| 0| { 187| 0| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, ------------------ | | 39| 0|#define G_IO_ERROR g_io_error_quark() ------------------ 188| 0| _("Input stream doesn’t implement read")); ------------------ | | 17| 0|#define _(String) glib_gettext(String) ------------------ 189| 0| return -1; 190| 0| } 191| | 192| 120k| if (!g_input_stream_set_pending (stream, error)) ------------------ | Branch (192:7): [True: 0, False: 120k] ------------------ 193| 0| return -1; 194| | 195| 120k| if (cancellable) ------------------ | Branch (195:7): [True: 0, False: 120k] ------------------ 196| 0| g_cancellable_push_current (cancellable); 197| | 198| 120k| res = class->read_fn (stream, buffer, count, cancellable, error); 199| | 200| 120k| if (cancellable) ------------------ | Branch (200:7): [True: 0, False: 120k] ------------------ 201| 0| g_cancellable_pop_current (cancellable); 202| | 203| 120k| g_input_stream_clear_pending (stream); 204| | 205| 120k| return res; 206| 120k|} g_input_stream_close: 520| 3.85k|{ 521| 3.85k| GInputStreamClass *class; 522| 3.85k| gboolean res; 523| | 524| 3.85k| g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 26.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 525| | 526| 3.85k| class = G_INPUT_STREAM_GET_CLASS (stream); ------------------ | | 37| 3.85k|#define G_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_INPUT_STREAM, GInputStreamClass)) | | ------------------ | | | | 527| 3.85k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 3.85k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ 527| | 528| 3.85k| if (stream->priv->closed) ------------------ | Branch (528:7): [True: 0, False: 3.85k] ------------------ 529| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 530| | 531| 3.85k| res = TRUE; ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 532| | 533| 3.85k| if (!g_input_stream_set_pending (stream, error)) ------------------ | Branch (533:7): [True: 0, False: 3.85k] ------------------ 534| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 535| | 536| 3.85k| if (cancellable) ------------------ | Branch (536:7): [True: 0, False: 3.85k] ------------------ 537| 0| g_cancellable_push_current (cancellable); 538| | 539| 3.85k| if (class->close_fn) ------------------ | Branch (539:7): [True: 3.85k, False: 0] ------------------ 540| 3.85k| res = class->close_fn (stream, cancellable, error); 541| | 542| 3.85k| if (cancellable) ------------------ | Branch (542:7): [True: 0, False: 3.85k] ------------------ 543| 0| g_cancellable_pop_current (cancellable); 544| | 545| 3.85k| g_input_stream_clear_pending (stream); 546| | 547| 3.85k| stream->priv->closed = TRUE; ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 548| | 549| 3.85k| return res; 550| 3.85k|} g_input_stream_set_pending: 1231| 124k|{ 1232| 124k| g_return_val_if_fail (G_IS_INPUT_STREAM (stream), FALSE); ------------------ | | 643| 124k| G_STMT_START { \ | | ------------------ | | | | 874| 124k|#define G_STMT_START do | | ------------------ | | 644| 124k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 124k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 124k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 124k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 124k| int _g_boolean_var_; \ | | | | | | 1018| 870k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 124k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 124k] | | | | | | | Branch (1018:8): [True: 0, False: 124k] | | | | | | | Branch (1018:8): [True: 124k, False: 0] | | | | | | ------------------ | | | | | | 1019| 124k| _g_boolean_var_ = 1; \ | | | | | | 1020| 124k| else \ | | | | | | 1021| 124k| _g_boolean_var_ = 0; \ | | | | | | 1022| 124k| _g_boolean_var_; \ | | | | | | 1023| 124k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 124k, False: 0] | | | | ------------------ | | ------------------ | | 645| 124k| { } \ | | 646| 124k| else \ | | 647| 124k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 124k| } G_STMT_END | | ------------------ | | | | 882| 124k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 124k] | | | | ------------------ | | ------------------ ------------------ 1233| | 1234| 124k| if (stream->priv->closed) ------------------ | Branch (1234:7): [True: 0, False: 124k] ------------------ 1235| 0| { 1236| 0| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED, ------------------ | | 39| 0|#define G_IO_ERROR g_io_error_quark() ------------------ 1237| 0| _("Stream is already closed")); ------------------ | | 17| 0|#define _(String) glib_gettext(String) ------------------ 1238| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1239| 0| } 1240| | 1241| 124k| if (stream->priv->pending) ------------------ | Branch (1241:7): [True: 0, False: 124k] ------------------ 1242| 0| { 1243| 0| g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING, ------------------ | | 39| 0|#define G_IO_ERROR g_io_error_quark() ------------------ 1244| | /* Translators: This is an error you get if there is already an 1245| | * operation running against this stream when you try to start 1246| | * one */ 1247| 0| _("Stream has outstanding operation")); ------------------ | | 17| 0|#define _(String) glib_gettext(String) ------------------ 1248| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1249| 0| } 1250| | 1251| 124k| stream->priv->pending = TRUE; ------------------ | | 818| 124k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 124k|#define FALSE (0) | | ------------------ ------------------ 1252| 124k| return TRUE; ------------------ | | 818| 124k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 124k|#define FALSE (0) | | ------------------ ------------------ 1253| 124k|} g_input_stream_clear_pending: 1263| 124k|{ 1264| 124k| g_return_if_fail (G_IS_INPUT_STREAM (stream)); ------------------ | | 630| 124k| G_STMT_START { \ | | ------------------ | | | | 874| 124k|#define G_STMT_START do | | ------------------ | | 631| 124k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 124k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 124k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 124k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 124k| int _g_boolean_var_; \ | | | | | | 1018| 870k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 124k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 124k] | | | | | | | Branch (1018:8): [True: 0, False: 124k] | | | | | | | Branch (1018:8): [True: 124k, False: 0] | | | | | | ------------------ | | | | | | 1019| 124k| _g_boolean_var_ = 1; \ | | | | | | 1020| 124k| else \ | | | | | | 1021| 124k| _g_boolean_var_ = 0; \ | | | | | | 1022| 124k| _g_boolean_var_; \ | | | | | | 1023| 124k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 124k, False: 0] | | | | ------------------ | | ------------------ | | 632| 124k| { } \ | | 633| 124k| else \ | | 634| 124k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 124k| } G_STMT_END | | ------------------ | | | | 882| 124k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 124k] | | | | ------------------ | | ------------------ ------------------ 1265| | 1266| 124k| stream->priv->pending = FALSE; ------------------ | | 814| 124k|#define FALSE (0) ------------------ 1267| 124k|} ginputstream.c:g_input_stream_class_init: 107| 1|{ 108| 1| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); ------------------ | | 63| 1|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 1|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 1| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 109| | 110| 1| gobject_class->dispose = g_input_stream_dispose; 111| | 112| 1| klass->skip = g_input_stream_real_skip; 113| 1| klass->read_async = g_input_stream_real_read_async; 114| 1| klass->read_finish = g_input_stream_real_read_finish; 115| 1| klass->skip_async = g_input_stream_real_skip_async; 116| 1| klass->skip_finish = g_input_stream_real_skip_finish; 117| 1| klass->close_async = g_input_stream_real_close_async; 118| 1| klass->close_finish = g_input_stream_real_close_finish; 119| 1|} ginputstream.c:g_input_stream_dispose: 93| 3.85k|{ 94| 3.85k| GInputStream *stream; 95| | 96| 3.85k| stream = G_INPUT_STREAM (object); ------------------ | | 33| 3.85k|#define G_INPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_INPUT_STREAM, GInputStream)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 97| | 98| 3.85k| if (!stream->priv->closed) ------------------ | Branch (98:7): [True: 3.85k, False: 0] ------------------ 99| 3.85k| g_input_stream_close (stream, NULL, NULL); 100| | 101| 3.85k| G_OBJECT_CLASS (g_input_stream_parent_class)->dispose (object); ------------------ | | 63| 3.85k|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 3.85k|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 3.85k| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 102| 3.85k|} ginputstream.c:g_input_stream_init: 123| 3.85k|{ 124| 3.85k| stream->priv = g_input_stream_get_instance_private (stream); 125| 3.85k|} g_memory_input_stream_new: 177| 3.85k|{ 178| 3.85k| GInputStream *stream; 179| | 180| 3.85k| stream = g_object_new (G_TYPE_MEMORY_INPUT_STREAM, NULL); ------------------ | | 32| 3.85k|#define G_TYPE_MEMORY_INPUT_STREAM (g_memory_input_stream_get_type ()) ------------------ 181| | 182| 3.85k| return stream; 183| 3.85k|} g_memory_input_stream_new_from_bytes: 222| 3.85k|{ 223| | 224| 3.85k| GInputStream *stream; 225| | 226| 3.85k| stream = g_memory_input_stream_new (); 227| | 228| 3.85k| g_memory_input_stream_add_bytes (G_MEMORY_INPUT_STREAM (stream), ------------------ | | 33| 3.85k|#define G_MEMORY_INPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_MEMORY_INPUT_STREAM, GMemoryInputStream)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 229| 3.85k| bytes); 230| | 231| 3.85k| return stream; 232| 3.85k|} g_memory_input_stream_add_bytes: 276| 3.85k|{ 277| 3.85k| GMemoryInputStreamPrivate *priv; 278| | 279| 3.85k| g_return_if_fail (G_IS_MEMORY_INPUT_STREAM (stream)); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 26.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 280| 3.85k| g_return_if_fail (bytes != NULL); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 281| | 282| 3.85k| priv = stream->priv; 283| | 284| 3.85k| priv->chunks = g_slist_append (priv->chunks, g_bytes_ref (bytes)); 285| 3.85k| priv->len += g_bytes_get_size (bytes); 286| 3.85k|} gmemoryinputstream.c:g_memory_input_stream_class_init: 113| 1|{ 114| 1| GObjectClass *object_class; 115| 1| GInputStreamClass *istream_class; 116| | 117| 1| object_class = G_OBJECT_CLASS (klass); ------------------ | | 63| 1|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 1|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 1| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 118| 1| object_class->finalize = g_memory_input_stream_finalize; 119| | 120| 1| istream_class = G_INPUT_STREAM_CLASS (klass); ------------------ | | 34| 1|#define G_INPUT_STREAM_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_INPUT_STREAM, GInputStreamClass)) | | ------------------ | | | | 553| 1|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 1| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 121| 1| istream_class->read_fn = g_memory_input_stream_read; 122| 1| istream_class->skip = g_memory_input_stream_skip; 123| 1| istream_class->close_fn = g_memory_input_stream_close; 124| | 125| 1| istream_class->skip_async = g_memory_input_stream_skip_async; 126| 1| istream_class->skip_finish = g_memory_input_stream_skip_finish; 127| 1| istream_class->close_async = g_memory_input_stream_close_async; 128| 1| istream_class->close_finish = g_memory_input_stream_close_finish; 129| 1|} gmemoryinputstream.c:g_memory_input_stream_finalize: 133| 3.85k|{ 134| 3.85k| GMemoryInputStream *stream; 135| 3.85k| GMemoryInputStreamPrivate *priv; 136| | 137| 3.85k| stream = G_MEMORY_INPUT_STREAM (object); ------------------ | | 33| 3.85k|#define G_MEMORY_INPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_MEMORY_INPUT_STREAM, GMemoryInputStream)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 138| 3.85k| priv = stream->priv; 139| | 140| 3.85k| g_slist_free_full (priv->chunks, (GDestroyNotify)g_bytes_unref); 141| | 142| 3.85k| G_OBJECT_CLASS (g_memory_input_stream_parent_class)->finalize (object); ------------------ | | 63| 3.85k|#define G_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 553| 3.85k|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | | | ------------------ | | | | | | 2302| 3.85k| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | | | ------------------ | | ------------------ ------------------ 143| 3.85k|} gmemoryinputstream.c:g_memory_input_stream_read: 294| 120k|{ 295| 120k| GMemoryInputStream *memory_stream; 296| 120k| GMemoryInputStreamPrivate *priv; 297| 120k| GSList *l; 298| 120k| GBytes *chunk; 299| 120k| gsize len; 300| 120k| gsize offset, start, rest, size; 301| | 302| 120k| memory_stream = G_MEMORY_INPUT_STREAM (stream); ------------------ | | 33| 120k|#define G_MEMORY_INPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_MEMORY_INPUT_STREAM, GMemoryInputStream)) | | ------------------ | | | | 484| 120k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 120k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 303| 120k| priv = memory_stream->priv; 304| | 305| 120k| count = MIN (count, priv->len - priv->pos); ------------------ | | 825| 120k|#define MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (825:21): [True: 116k, False: 4.42k] | | ------------------ ------------------ 306| | 307| 120k| offset = 0; 308| 121k| for (l = priv->chunks; l; l = l->next) ------------------ | Branch (308:26): [True: 120k, False: 739] ------------------ 309| 120k| { 310| 120k| chunk = (GBytes *)l->data; 311| 120k| len = g_bytes_get_size (chunk); 312| | 313| 120k| if (offset + len > priv->pos) ------------------ | Branch (313:11): [True: 119k, False: 739] ------------------ 314| 119k| break; 315| | 316| 739| offset += len; 317| 739| } 318| | 319| 120k| start = priv->pos - offset; 320| 120k| rest = count; 321| | 322| 240k| for (; l && rest > 0; l = l->next) ------------------ | Branch (322:10): [True: 119k, False: 120k] | Branch (322:15): [True: 119k, False: 0] ------------------ 323| 119k| { 324| 119k| const guint8* chunk_data; 325| 119k| chunk = (GBytes *)l->data; 326| | 327| 119k| chunk_data = g_bytes_get_data (chunk, &len); 328| | 329| 119k| size = MIN (rest, len - start); ------------------ | | 825| 119k|#define MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (825:21): [True: 116k, False: 3.68k] | | ------------------ ------------------ 330| | 331| 119k| memcpy ((guint8 *)buffer + (count - rest), chunk_data + start, size); 332| 119k| rest -= size; 333| | 334| 119k| start = 0; 335| 119k| } 336| | 337| 120k| priv->pos += count; 338| | 339| 120k| return count; 340| 120k|} gmemoryinputstream.c:g_memory_input_stream_close: 364| 3.85k|{ 365| 3.85k| return TRUE; ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 366| 3.85k|} gmemoryinputstream.c:g_memory_input_stream_init: 164| 3.85k|{ 165| 3.85k| stream->priv = g_memory_input_stream_get_instance_private (stream); 166| 3.85k|} gmemoryinputstream.c:g_memory_input_stream_seekable_iface_init: 147| 1|{ 148| 1| iface->tell = g_memory_input_stream_tell; 149| 1| iface->can_seek = g_memory_input_stream_can_seek; 150| 1| iface->seek = g_memory_input_stream_seek; 151| 1| iface->can_truncate = g_memory_input_stream_can_truncate; 152| 1| iface->truncate_fn = g_memory_input_stream_truncate; 153| 1|} gmemoryinputstream.c:g_memory_input_stream_tell: 426| 3.85k|{ 427| 3.85k| GMemoryInputStream *memory_stream; 428| 3.85k| GMemoryInputStreamPrivate *priv; 429| | 430| 3.85k| memory_stream = G_MEMORY_INPUT_STREAM (seekable); ------------------ | | 33| 3.85k|#define G_MEMORY_INPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_MEMORY_INPUT_STREAM, GMemoryInputStream)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 431| 3.85k| priv = memory_stream->priv; 432| | 433| 3.85k| return priv->pos; 434| 3.85k|} gmemoryinputstream.c:g_memory_input_stream_can_seek: 438| 13.4k|{ 439| 13.4k| return TRUE; ------------------ | | 818| 13.4k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 13.4k|#define FALSE (0) | | ------------------ ------------------ 440| 13.4k|} gmemoryinputstream.c:g_memory_input_stream_seek: 448| 123k|{ 449| 123k| GMemoryInputStream *memory_stream; 450| 123k| GMemoryInputStreamPrivate *priv; 451| 123k| goffset absolute; 452| | 453| 123k| memory_stream = G_MEMORY_INPUT_STREAM (seekable); ------------------ | | 33| 123k|#define G_MEMORY_INPUT_STREAM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_MEMORY_INPUT_STREAM, GMemoryInputStream)) | | ------------------ | | | | 484| 123k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 123k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 454| 123k| priv = memory_stream->priv; 455| | 456| 123k| switch (type) 457| 123k| { 458| 0| case G_SEEK_CUR: ------------------ | Branch (458:5): [True: 0, False: 123k] ------------------ 459| 0| absolute = priv->pos + offset; 460| 0| break; 461| | 462| 120k| case G_SEEK_SET: ------------------ | Branch (462:5): [True: 120k, False: 3.85k] ------------------ 463| 120k| absolute = offset; 464| 120k| break; 465| | 466| 3.85k| case G_SEEK_END: ------------------ | Branch (466:5): [True: 3.85k, False: 120k] ------------------ 467| 3.85k| absolute = priv->len + offset; 468| 3.85k| break; 469| | 470| 0| default: ------------------ | Branch (470:5): [True: 0, False: 123k] ------------------ 471| 0| g_set_error_literal (error, 472| 0| G_IO_ERROR, ------------------ | | 39| 0|#define G_IO_ERROR g_io_error_quark() ------------------ 473| 0| G_IO_ERROR_INVALID_ARGUMENT, 474| 0| _("Invalid GSeekType supplied")); ------------------ | | 17| 0|#define _(String) glib_gettext(String) ------------------ 475| | 476| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 477| 123k| } 478| | 479| 123k| if (absolute < 0 || (gsize) absolute > priv->len) ------------------ | Branch (479:7): [True: 0, False: 123k] | Branch (479:23): [True: 15, False: 123k] ------------------ 480| 15| { 481| 15| g_set_error_literal (error, 482| 15| G_IO_ERROR, ------------------ | | 39| 15|#define G_IO_ERROR g_io_error_quark() ------------------ 483| 15| G_IO_ERROR_INVALID_ARGUMENT, 484| 15| _("Invalid seek request")); ------------------ | | 17| 15|#define _(String) glib_gettext(String) ------------------ 485| 15| return FALSE; ------------------ | | 814| 15|#define FALSE (0) ------------------ 486| 15| } 487| | 488| 123k| priv->pos = absolute; 489| | 490| 123k| return TRUE; ------------------ | | 818| 123k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 123k|#define FALSE (0) | | ------------------ ------------------ 491| 123k|} gmemoryinputstream.c:g_memory_input_stream_pollable_iface_init: 157| 1|{ 158| 1| iface->is_readable = g_memory_input_stream_is_readable; 159| 1| iface->create_source = g_memory_input_stream_create_source; 160| 1|} gpollableinputstream.c:g_pollable_input_stream_default_init: 51| 1|{ 52| 1| iface->can_poll = g_pollable_input_stream_default_can_poll; 53| 1| iface->read_nonblocking = g_pollable_input_stream_default_read_nonblocking; 54| 1|} g_seekable_tell: 66| 3.85k|{ 67| 3.85k| GSeekableIface *iface; 68| | 69| 3.85k| g_return_val_if_fail (G_IS_SEEKABLE (seekable), 0); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 26.9k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 70| | 71| 3.85k| iface = G_SEEKABLE_GET_IFACE (seekable); ------------------ | | 35| 3.85k|#define G_SEEKABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_SEEKABLE, GSeekableIface)) | | ------------------ | | | | 540| 3.85k|#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2310| 3.85k|#define _G_TYPE_IGI(ip, gt, ct) ((ct*) g_type_interface_peek (((GTypeInstance*) ip)->g_class, gt)) | | | | ------------------ | | ------------------ ------------------ 72| | 73| 3.85k| return (* iface->tell) (seekable); 74| 3.85k|} g_seekable_can_seek: 86| 13.4k|{ 87| 13.4k| GSeekableIface *iface; 88| | 89| 13.4k| g_return_val_if_fail (G_IS_SEEKABLE (seekable), FALSE); ------------------ | | 643| 13.4k| G_STMT_START { \ | | ------------------ | | | | 874| 13.4k|#define G_STMT_START do | | ------------------ | | 644| 13.4k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 13.4k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 13.4k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 13.4k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 13.4k| int _g_boolean_var_; \ | | | | | | 1018| 93.8k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 13.4k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 13.4k] | | | | | | | Branch (1018:8): [True: 0, False: 13.4k] | | | | | | | Branch (1018:8): [True: 13.4k, False: 0] | | | | | | ------------------ | | | | | | 1019| 13.4k| _g_boolean_var_ = 1; \ | | | | | | 1020| 13.4k| else \ | | | | | | 1021| 13.4k| _g_boolean_var_ = 0; \ | | | | | | 1022| 13.4k| _g_boolean_var_; \ | | | | | | 1023| 13.4k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 13.4k, False: 0] | | | | ------------------ | | ------------------ | | 645| 13.4k| { } \ | | 646| 13.4k| else \ | | 647| 13.4k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 13.4k| } G_STMT_END | | ------------------ | | | | 882| 13.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 13.4k] | | | | ------------------ | | ------------------ ------------------ 90| | 91| 13.4k| iface = G_SEEKABLE_GET_IFACE (seekable); ------------------ | | 35| 13.4k|#define G_SEEKABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_SEEKABLE, GSeekableIface)) | | ------------------ | | | | 540| 13.4k|#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2310| 13.4k|#define _G_TYPE_IGI(ip, gt, ct) ((ct*) g_type_interface_peek (((GTypeInstance*) ip)->g_class, gt)) | | | | ------------------ | | ------------------ ------------------ 92| | 93| 13.4k| return (* iface->can_seek) (seekable); 94| 13.4k|} g_seekable_seek: 130| 123k|{ 131| 123k| GSeekableIface *iface; 132| | 133| 123k| g_return_val_if_fail (G_IS_SEEKABLE (seekable), FALSE); ------------------ | | 643| 123k| G_STMT_START { \ | | ------------------ | | | | 874| 123k|#define G_STMT_START do | | ------------------ | | 644| 123k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 123k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 123k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 123k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 123k| int _g_boolean_var_; \ | | | | | | 1018| 867k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 123k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 123k] | | | | | | | Branch (1018:8): [True: 0, False: 123k] | | | | | | | Branch (1018:8): [True: 123k, False: 0] | | | | | | ------------------ | | | | | | 1019| 123k| _g_boolean_var_ = 1; \ | | | | | | 1020| 123k| else \ | | | | | | 1021| 123k| _g_boolean_var_ = 0; \ | | | | | | 1022| 123k| _g_boolean_var_; \ | | | | | | 1023| 123k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 123k, False: 0] | | | | ------------------ | | ------------------ | | 645| 123k| { } \ | | 646| 123k| else \ | | 647| 123k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 123k| } G_STMT_END | | ------------------ | | | | 882| 123k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 123k] | | | | ------------------ | | ------------------ ------------------ 134| | 135| 123k| iface = G_SEEKABLE_GET_IFACE (seekable); ------------------ | | 35| 123k|#define G_SEEKABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_TYPE_SEEKABLE, GSeekableIface)) | | ------------------ | | | | 540| 123k|#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2310| 123k|#define _G_TYPE_IGI(ip, gt, ct) ((ct*) g_type_interface_peek (((GTypeInstance*) ip)->g_class, gt)) | | | | ------------------ | | ------------------ ------------------ 136| | 137| 123k| return (* iface->seek) (seekable, offset, type, cancellable, error); 138| 123k|} gseekable.c:g_seekable_default_init: 53| 1|{ 54| 1|} g_array_sized_new: 260| 6.46k|{ 261| 6.46k| GRealArray *array; 262| | 263| 6.46k| g_return_val_if_fail (elt_size > 0, NULL); ------------------ | | 643| 6.46k| G_STMT_START { \ | | ------------------ | | | | 874| 6.46k|#define G_STMT_START do | | ------------------ | | 644| 6.46k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 6.46k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 6.46k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 6.46k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 6.46k| int _g_boolean_var_; \ | | | | | | 1018| 6.46k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 6.46k, False: 0] | | | | | | ------------------ | | | | | | 1019| 6.46k| _g_boolean_var_ = 1; \ | | | | | | 1020| 6.46k| else \ | | | | | | 1021| 6.46k| _g_boolean_var_ = 0; \ | | | | | | 1022| 6.46k| _g_boolean_var_; \ | | | | | | 1023| 6.46k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 6.46k, False: 0] | | | | ------------------ | | ------------------ | | 645| 6.46k| { } \ | | 646| 6.46k| else \ | | 647| 6.46k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 6.46k| } G_STMT_END | | ------------------ | | | | 882| 6.46k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 6.46k] | | | | ------------------ | | ------------------ ------------------ 264| | 265| 6.46k| array = g_slice_new (GRealArray); ------------------ | | 46| 6.46k|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) ------------------ 266| | 267| 6.46k| array->data = NULL; 268| 6.46k| array->len = 0; 269| 6.46k| array->alloc = 0; 270| 6.46k| array->zero_terminated = (zero_terminated ? 1 : 0); ------------------ | Branch (270:29): [True: 0, False: 6.46k] ------------------ 271| 6.46k| array->clear = (clear ? 1 : 0); ------------------ | Branch (271:29): [True: 0, False: 6.46k] ------------------ 272| 6.46k| array->elt_size = elt_size; 273| 6.46k| array->clear_func = NULL; 274| | 275| 6.46k| g_atomic_ref_count_init (&array->ref_count); 276| | 277| 6.46k| if (array->zero_terminated || reserved_size != 0) ------------------ | Branch (277:7): [True: 0, False: 6.46k] | Branch (277:33): [True: 0, False: 6.46k] ------------------ 278| 0| { 279| 0| g_array_maybe_expand (array, reserved_size); 280| 0| g_array_zero_terminate(array); ------------------ | | 157| 0|#define g_array_zero_terminate(array) G_STMT_START{ \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 158| 0| if ((array)->zero_terminated) \ | | ------------------ | | | Branch (158:7): [True: 0, False: 0] | | ------------------ | | 159| 0| g_array_elt_zero ((array), (array)->len, 1); \ | | ------------------ | | | | 156| 0| (memset (g_array_elt_pos ((array), pos), 0, g_array_elt_len ((array), len))) | | | | ------------------ | | | | | | 154| 0|#define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i))) | | | | | | ------------------ | | | | | | | | 153| 0|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) | | | | | | ------------------ | | | | ------------------ | | | | (memset (g_array_elt_pos ((array), pos), 0, g_array_elt_len ((array), len))) | | | | ------------------ | | | | | | 153| 0|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) | | | | ------------------ | | ------------------ | | 160| 0|}G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 281| 0| } 282| | 283| 6.46k| return (GArray*) array; 284| 6.46k|} g_array_unref: 358| 3.55k|{ 359| 3.55k| GRealArray *rarray = (GRealArray*) array; 360| 3.55k| g_return_if_fail (array); ------------------ | | 630| 3.55k| G_STMT_START { \ | | ------------------ | | | | 874| 3.55k|#define G_STMT_START do | | ------------------ | | 631| 3.55k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.55k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.55k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.55k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.55k| int _g_boolean_var_; \ | | | | | | 1018| 3.55k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.55k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.55k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.55k| else \ | | | | | | 1021| 3.55k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.55k| _g_boolean_var_; \ | | | | | | 1023| 3.55k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.55k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.55k| { } \ | | 633| 3.55k| else \ | | 634| 3.55k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.55k| } G_STMT_END | | ------------------ | | | | 882| 3.55k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.55k] | | | | ------------------ | | ------------------ ------------------ 361| | 362| 3.55k| if (g_atomic_ref_count_dec (&rarray->ref_count)) ------------------ | Branch (362:7): [True: 3.55k, False: 0] ------------------ 363| 3.55k| array_free (rarray, FREE_SEGMENT); 364| 3.55k|} g_array_free: 412| 2.91k|{ 413| 2.91k| GRealArray *array = (GRealArray*) farray; 414| 2.91k| ArrayFreeFlags flags; 415| | 416| 2.91k| g_return_val_if_fail (array, NULL); ------------------ | | 643| 2.91k| G_STMT_START { \ | | ------------------ | | | | 874| 2.91k|#define G_STMT_START do | | ------------------ | | 644| 2.91k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.91k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.91k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.91k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.91k| int _g_boolean_var_; \ | | | | | | 1018| 2.91k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.91k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.91k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.91k| else \ | | | | | | 1021| 2.91k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.91k| _g_boolean_var_; \ | | | | | | 1023| 2.91k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.91k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.91k| { } \ | | 646| 2.91k| else \ | | 647| 2.91k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.91k| } G_STMT_END | | ------------------ | | | | 882| 2.91k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.91k] | | | | ------------------ | | ------------------ ------------------ 417| | 418| 2.91k| flags = (free_segment ? FREE_SEGMENT : 0); ------------------ | Branch (418:12): [True: 0, False: 2.91k] ------------------ 419| | 420| | /* if others are holding a reference, preserve the wrapper but do free/return the data */ 421| 2.91k| if (!g_atomic_ref_count_dec (&array->ref_count)) ------------------ | Branch (421:7): [True: 0, False: 2.91k] ------------------ 422| 0| flags |= PRESERVE_WRAPPER; 423| | 424| 2.91k| return array_free (array, flags); 425| 2.91k|} g_array_append_vals: 491| 41.4k|{ 492| 41.4k| GRealArray *array = (GRealArray*) farray; 493| | 494| 41.4k| g_return_val_if_fail (array, NULL); ------------------ | | 643| 41.4k| G_STMT_START { \ | | ------------------ | | | | 874| 41.4k|#define G_STMT_START do | | ------------------ | | 644| 41.4k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 41.4k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 41.4k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 41.4k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 41.4k| int _g_boolean_var_; \ | | | | | | 1018| 41.4k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 41.4k, False: 0] | | | | | | ------------------ | | | | | | 1019| 41.4k| _g_boolean_var_ = 1; \ | | | | | | 1020| 41.4k| else \ | | | | | | 1021| 41.4k| _g_boolean_var_ = 0; \ | | | | | | 1022| 41.4k| _g_boolean_var_; \ | | | | | | 1023| 41.4k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 41.4k, False: 0] | | | | ------------------ | | ------------------ | | 645| 41.4k| { } \ | | 646| 41.4k| else \ | | 647| 41.4k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 41.4k| } G_STMT_END | | ------------------ | | | | 882| 41.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 41.4k] | | | | ------------------ | | ------------------ ------------------ 495| | 496| 41.4k| if (len == 0) ------------------ | Branch (496:7): [True: 0, False: 41.4k] ------------------ 497| 0| return farray; 498| | 499| 41.4k| g_array_maybe_expand (array, len); 500| | 501| 41.4k| memcpy (g_array_elt_pos (array, array->len), data, ------------------ | | 154| 41.4k|#define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i))) | | ------------------ | | | | 153| 41.4k|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) | | ------------------ ------------------ 502| 41.4k| g_array_elt_len (array, len)); ------------------ | | 153| 41.4k|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) ------------------ 503| | 504| 41.4k| array->len += len; 505| | 506| 41.4k| g_array_zero_terminate (array); ------------------ | | 157| 41.4k|#define g_array_zero_terminate(array) G_STMT_START{ \ | | ------------------ | | | | 874| 41.4k|#define G_STMT_START do | | ------------------ | | 158| 41.4k| if ((array)->zero_terminated) \ | | ------------------ | | | Branch (158:7): [True: 0, False: 41.4k] | | ------------------ | | 159| 41.4k| g_array_elt_zero ((array), (array)->len, 1); \ | | ------------------ | | | | 156| 0| (memset (g_array_elt_pos ((array), pos), 0, g_array_elt_len ((array), len))) | | | | ------------------ | | | | | | 154| 0|#define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i))) | | | | | | ------------------ | | | | | | | | 153| 0|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) | | | | | | ------------------ | | | | ------------------ | | | | (memset (g_array_elt_pos ((array), pos), 0, g_array_elt_len ((array), len))) | | | | ------------------ | | | | | | 153| 0|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) | | | | ------------------ | | ------------------ | | 160| 41.4k|}G_STMT_END | | ------------------ | | | | 882| 41.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 41.4k] | | | | ------------------ | | ------------------ ------------------ 507| | 508| 41.4k| return farray; 509| 41.4k|} g_ptr_array_new: 1110| 88|{ 1111| | return ptr_array_new (0, NULL); 1112| 88|} g_ptr_array_new_with_free_func: 1305| 46.6k|{ 1306| 46.6k| return ptr_array_new (0, element_free_func); 1307| 46.6k|} g_ptr_array_unref: 1395| 46.6k|{ 1396| 46.6k| GRealPtrArray *rarray = (GRealPtrArray *)array; 1397| | 1398| 46.6k| g_return_if_fail (array); ------------------ | | 630| 46.6k| G_STMT_START { \ | | ------------------ | | | | 874| 46.6k|#define G_STMT_START do | | ------------------ | | 631| 46.6k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 46.6k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 46.6k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 46.6k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 46.6k| int _g_boolean_var_; \ | | | | | | 1018| 46.6k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 46.6k, False: 0] | | | | | | ------------------ | | | | | | 1019| 46.6k| _g_boolean_var_ = 1; \ | | | | | | 1020| 46.6k| else \ | | | | | | 1021| 46.6k| _g_boolean_var_ = 0; \ | | | | | | 1022| 46.6k| _g_boolean_var_; \ | | | | | | 1023| 46.6k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 46.6k, False: 0] | | | | ------------------ | | ------------------ | | 632| 46.6k| { } \ | | 633| 46.6k| else \ | | 634| 46.6k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 46.6k| } G_STMT_END | | ------------------ | | | | 882| 46.6k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 46.6k] | | | | ------------------ | | ------------------ ------------------ 1399| | 1400| 46.6k| if (g_atomic_ref_count_dec (&rarray->ref_count)) ------------------ | Branch (1400:7): [True: 46.6k, False: 0] ------------------ 1401| 46.6k| ptr_array_free (array, FREE_SEGMENT); 1402| 46.6k|} g_ptr_array_free: 1430| 88|{ 1431| 88| GRealPtrArray *rarray = (GRealPtrArray *)array; 1432| 88| ArrayFreeFlags flags; 1433| | 1434| 88| g_return_val_if_fail (rarray, NULL); ------------------ | | 643| 88| G_STMT_START { \ | | ------------------ | | | | 874| 88|#define G_STMT_START do | | ------------------ | | 644| 88| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 88|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 88| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 88|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 88| int _g_boolean_var_; \ | | | | | | 1018| 88| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 88, False: 0] | | | | | | ------------------ | | | | | | 1019| 88| _g_boolean_var_ = 1; \ | | | | | | 1020| 88| else \ | | | | | | 1021| 88| _g_boolean_var_ = 0; \ | | | | | | 1022| 88| _g_boolean_var_; \ | | | | | | 1023| 88|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 88, False: 0] | | | | ------------------ | | ------------------ | | 645| 88| { } \ | | 646| 88| else \ | | 647| 88| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 88| } G_STMT_END | | ------------------ | | | | 882| 88|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 88] | | | | ------------------ | | ------------------ ------------------ 1435| | 1436| 88| flags = (free_segment ? FREE_SEGMENT : 0); ------------------ | Branch (1436:12): [True: 0, False: 88] ------------------ 1437| | 1438| | /* if others are holding a reference, preserve the wrapper but 1439| | * do free/return the data 1440| | */ 1441| 88| if (!g_atomic_ref_count_dec (&rarray->ref_count)) ------------------ | Branch (1441:7): [True: 0, False: 88] ------------------ 1442| 0| flags |= PRESERVE_WRAPPER; 1443| | 1444| 88| return ptr_array_free (array, flags); 1445| 88|} g_ptr_array_add: 1807| 80.1k|{ 1808| 80.1k| GRealPtrArray *rarray = (GRealPtrArray *)array; 1809| | 1810| 80.1k| g_return_if_fail (rarray); ------------------ | | 630| 80.1k| G_STMT_START { \ | | ------------------ | | | | 874| 80.1k|#define G_STMT_START do | | ------------------ | | 631| 80.1k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 80.1k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 80.1k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 80.1k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 80.1k| int _g_boolean_var_; \ | | | | | | 1018| 80.1k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 80.1k, False: 0] | | | | | | ------------------ | | | | | | 1019| 80.1k| _g_boolean_var_ = 1; \ | | | | | | 1020| 80.1k| else \ | | | | | | 1021| 80.1k| _g_boolean_var_ = 0; \ | | | | | | 1022| 80.1k| _g_boolean_var_; \ | | | | | | 1023| 80.1k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 80.1k, False: 0] | | | | ------------------ | | ------------------ | | 632| 80.1k| { } \ | | 633| 80.1k| else \ | | 634| 80.1k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 80.1k| } G_STMT_END | | ------------------ | | | | 882| 80.1k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 80.1k] | | | | ------------------ | | ------------------ ------------------ 1811| 80.1k| g_return_if_fail (rarray->len == 0 || (rarray->len != 0 && rarray->pdata != NULL)); ------------------ | | 630| 80.1k| G_STMT_START { \ | | ------------------ | | | | 874| 80.1k|#define G_STMT_START do | | ------------------ | | 631| 80.1k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 80.1k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 80.1k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 80.1k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 80.1k| int _g_boolean_var_; \ | | | | | | 1018| 341k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 60.2k, False: 0] | | | | | | | Branch (1018:8): [True: 60.2k, False: 0] | | | | | | | Branch (1018:8): [True: 19.9k, False: 60.2k] | | | | | | ------------------ | | | | | | 1019| 80.1k| _g_boolean_var_ = 1; \ | | | | | | 1020| 80.1k| else \ | | | | | | 1021| 80.1k| _g_boolean_var_ = 0; \ | | | | | | 1022| 80.1k| _g_boolean_var_; \ | | | | | | 1023| 80.1k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 80.1k, False: 0] | | | | ------------------ | | ------------------ | | 632| 80.1k| { } \ | | 633| 80.1k| else \ | | 634| 80.1k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 80.1k| } G_STMT_END | | ------------------ | | | | 882| 80.1k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 80.1k] | | | | ------------------ | | ------------------ ------------------ 1812| | 1813| 80.1k| g_ptr_array_maybe_expand (rarray, 1); 1814| | 1815| 80.1k| rarray->pdata[rarray->len++] = data; 1816| 80.1k|} g_byte_array_new: 2230| 6.46k|{ 2231| 6.46k| return (GByteArray *)g_array_sized_new (FALSE, FALSE, 1, 0); ------------------ | | 814| 6.46k|#define FALSE (0) ------------------ return (GByteArray *)g_array_sized_new (FALSE, FALSE, 1, 0); ------------------ | | 814| 6.46k|#define FALSE (0) ------------------ 2232| 6.46k|} g_byte_array_free: 2326| 2.91k|{ 2327| 2.91k| return (guint8 *)g_array_free ((GArray *)array, free_segment); 2328| 2.91k|} g_byte_array_free_to_bytes: 2350| 2.91k|{ 2351| 2.91k| gsize length; 2352| | 2353| 2.91k| g_return_val_if_fail (array != NULL, NULL); ------------------ | | 643| 2.91k| G_STMT_START { \ | | ------------------ | | | | 874| 2.91k|#define G_STMT_START do | | ------------------ | | 644| 2.91k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2.91k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.91k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.91k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.91k| int _g_boolean_var_; \ | | | | | | 1018| 2.91k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.91k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.91k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.91k| else \ | | | | | | 1021| 2.91k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.91k| _g_boolean_var_; \ | | | | | | 1023| 2.91k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2.91k, False: 0] | | | | ------------------ | | ------------------ | | 645| 2.91k| { } \ | | 646| 2.91k| else \ | | 647| 2.91k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2.91k| } G_STMT_END | | ------------------ | | | | 882| 2.91k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.91k] | | | | ------------------ | | ------------------ ------------------ 2354| | 2355| 2.91k| length = array->len; 2356| 2.91k| return g_bytes_new_take (g_byte_array_free (array, FALSE), length); ------------------ | | 814| 2.91k|#define FALSE (0) ------------------ 2357| 2.91k|} g_byte_array_unref: 2389| 3.55k|{ 2390| 3.55k| g_array_unref ((GArray *)array); 2391| 3.55k|} g_byte_array_append: 2408| 41.4k|{ 2409| 41.4k| g_array_append_vals ((GArray *)array, (guint8 *)data, len); 2410| | 2411| 41.4k| return array; 2412| 41.4k|} garray.c:array_free: 430| 6.46k|{ 431| 6.46k| gchar *segment; 432| | 433| 6.46k| if (flags & FREE_SEGMENT) ------------------ | Branch (433:7): [True: 3.55k, False: 2.91k] ------------------ 434| 3.55k| { 435| 3.55k| if (array->clear_func != NULL) ------------------ | Branch (435:11): [True: 0, False: 3.55k] ------------------ 436| 0| { 437| 0| guint i; 438| | 439| 0| for (i = 0; i < array->len; i++) ------------------ | Branch (439:23): [True: 0, False: 0] ------------------ 440| 0| array->clear_func (g_array_elt_pos (array, i)); ------------------ | | 154| 0|#define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i))) | | ------------------ | | | | 153| 0|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) | | ------------------ ------------------ 441| 0| } 442| | 443| 3.55k| g_free (array->data); 444| 3.55k| segment = NULL; 445| 3.55k| } 446| 2.91k| else 447| 2.91k| segment = (gchar*) array->data; 448| | 449| 6.46k| if (flags & PRESERVE_WRAPPER) ------------------ | Branch (449:7): [True: 0, False: 6.46k] ------------------ 450| 0| { 451| 0| array->data = NULL; 452| 0| array->len = 0; 453| 0| array->alloc = 0; 454| 0| } 455| 6.46k| else 456| 6.46k| { 457| 6.46k| g_slice_free1 (sizeof (GRealArray), array); 458| 6.46k| } 459| | 460| 6.46k| return segment; 461| 6.46k|} garray.c:g_array_maybe_expand: 973| 41.4k|{ 974| 41.4k| guint want_alloc; 975| | 976| | /* Detect potential overflow */ 977| 41.4k| if G_UNLIKELY ((G_MAXUINT - array->len) < len) ------------------ | | 1025| 41.4k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 41.4k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 41.4k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 41.4k| int _g_boolean_var_; \ | | | | 1018| 41.4k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 41.4k] | | | | ------------------ | | | | 1019| 41.4k| _g_boolean_var_ = 1; \ | | | | 1020| 41.4k| else \ | | | | 1021| 41.4k| _g_boolean_var_ = 0; \ | | | | 1022| 41.4k| _g_boolean_var_; \ | | | | 1023| 41.4k|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 41.4k] | | ------------------ ------------------ 978| 41.4k| g_error ("adding %u to array would overflow", len); ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 979| | 980| 41.4k| want_alloc = g_array_elt_len (array, array->len + len + ------------------ | | 153| 41.4k|#define g_array_elt_len(array,i) ((array)->elt_size * (i)) ------------------ 981| 41.4k| array->zero_terminated); 982| | 983| 41.4k| if (want_alloc > array->alloc) ------------------ | Branch (983:7): [True: 7.76k, False: 33.6k] ------------------ 984| 7.76k| { 985| 7.76k| want_alloc = g_nearest_pow (want_alloc); 986| 7.76k| want_alloc = MAX (want_alloc, MIN_ARRAY_SIZE); ------------------ | | 822| 7.76k|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 1.78k, False: 5.98k] | | ------------------ ------------------ 987| | 988| 7.76k| array->data = g_realloc (array->data, want_alloc); 989| | 990| 7.76k| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 7.76k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 7.76k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.76k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.76k| int _g_boolean_var_; \ | | | | 1018| 7.76k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 7.76k] | | | | ------------------ | | | | 1019| 7.76k| _g_boolean_var_ = 1; \ | | | | 1020| 7.76k| else \ | | | | 1021| 7.76k| _g_boolean_var_ = 0; \ | | | | 1022| 7.76k| _g_boolean_var_; \ | | | | 1023| 7.76k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 7.76k] | | ------------------ ------------------ 991| 0| memset (array->data + array->alloc, 0, want_alloc - array->alloc); 992| | 993| 7.76k| array->alloc = want_alloc; 994| 7.76k| } 995| 41.4k|} garray.c:g_nearest_pow: 953| 29.5k|{ 954| 29.5k| guint n = num - 1; 955| | 956| 29.5k| g_assert (num > 0); ------------------ | | 231| 29.5k|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 29.5k|#define G_STMT_START do | | ------------------ | | 232| 29.5k| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 29.5k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 29.5k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 29.5k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 29.5k| int _g_boolean_var_; \ | | | | | | 1018| 29.5k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 29.5k, False: 0] | | | | | | ------------------ | | | | | | 1019| 29.5k| _g_boolean_var_ = 1; \ | | | | | | 1020| 29.5k| else \ | | | | | | 1021| 29.5k| _g_boolean_var_ = 0; \ | | | | | | 1022| 29.5k| _g_boolean_var_; \ | | | | | | 1023| 29.5k|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 29.5k, False: 0] | | | | ------------------ | | ------------------ | | 233| 29.5k| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 29.5k| } G_STMT_END | | ------------------ | | | | 882| 29.5k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 29.5k] | | | | ------------------ | | ------------------ ------------------ 957| | 958| 29.5k| n |= n >> 1; 959| 29.5k| n |= n >> 2; 960| 29.5k| n |= n >> 4; 961| 29.5k| n |= n >> 8; 962| 29.5k| n |= n >> 16; 963| |#if SIZEOF_INT == 8 964| | n |= n >> 32; 965| |#endif 966| | 967| 29.5k| return n + 1; 968| 29.5k|} garray.c:ptr_array_new: 1083| 46.7k|{ 1084| 46.7k| GRealPtrArray *array; 1085| | 1086| 46.7k| array = g_slice_new (GRealPtrArray); ------------------ | | 46| 46.7k|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) ------------------ 1087| | 1088| 46.7k| array->pdata = NULL; 1089| 46.7k| array->len = 0; 1090| 46.7k| array->alloc = 0; 1091| 46.7k| array->element_free_func = element_free_func; 1092| | 1093| 46.7k| g_atomic_ref_count_init (&array->ref_count); 1094| | 1095| 46.7k| if (reserved_size != 0) ------------------ | Branch (1095:7): [True: 0, False: 46.7k] ------------------ 1096| 0| g_ptr_array_maybe_expand (array, reserved_size); 1097| | 1098| 46.7k| return (GPtrArray *) array; 1099| 46.7k|} garray.c:ptr_array_free: 1450| 46.7k|{ 1451| 46.7k| GRealPtrArray *rarray = (GRealPtrArray *)array; 1452| 46.7k| gpointer *segment; 1453| | 1454| 46.7k| if (flags & FREE_SEGMENT) ------------------ | Branch (1454:7): [True: 46.6k, False: 88] ------------------ 1455| 46.6k| { 1456| | /* Data here is stolen and freed manually. It is an 1457| | * error to attempt to access the array data (including 1458| | * mutating the array bounds) during destruction). 1459| | * 1460| | * https://bugzilla.gnome.org/show_bug.cgi?id=769064 1461| | */ 1462| 46.6k| gpointer *stolen_pdata = g_steal_pointer (&rarray->pdata); ------------------ | | 222| 46.6k|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 1463| 46.6k| if (rarray->element_free_func != NULL) ------------------ | Branch (1463:11): [True: 46.6k, False: 0] ------------------ 1464| 46.6k| { 1465| 46.6k| guint i; 1466| | 1467| 126k| for (i = 0; i < rarray->len; ++i) ------------------ | Branch (1467:23): [True: 79.6k, False: 46.6k] ------------------ 1468| 79.6k| rarray->element_free_func (stolen_pdata[i]); 1469| 46.6k| } 1470| | 1471| 46.6k| g_free (stolen_pdata); 1472| 46.6k| segment = NULL; 1473| 46.6k| } 1474| 88| else 1475| 88| segment = rarray->pdata; 1476| | 1477| 46.7k| if (flags & PRESERVE_WRAPPER) ------------------ | Branch (1477:7): [True: 0, False: 46.7k] ------------------ 1478| 0| { 1479| 0| rarray->pdata = NULL; 1480| 0| rarray->len = 0; 1481| 0| rarray->alloc = 0; 1482| 0| } 1483| 46.7k| else 1484| 46.7k| { 1485| 46.7k| g_slice_free1 (sizeof (GRealPtrArray), rarray); 1486| 46.7k| } 1487| | 1488| 46.7k| return segment; 1489| 46.7k|} garray.c:g_ptr_array_maybe_expand: 1494| 80.1k|{ 1495| | /* Detect potential overflow */ 1496| 80.1k| if G_UNLIKELY ((G_MAXUINT - array->len) < len) ------------------ | | 1025| 80.1k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 80.1k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 80.1k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 80.1k| int _g_boolean_var_; \ | | | | 1018| 80.1k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 80.1k] | | | | ------------------ | | | | 1019| 80.1k| _g_boolean_var_ = 1; \ | | | | 1020| 80.1k| else \ | | | | 1021| 80.1k| _g_boolean_var_ = 0; \ | | | | 1022| 80.1k| _g_boolean_var_; \ | | | | 1023| 80.1k|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 80.1k] | | ------------------ ------------------ 1497| 80.1k| g_error ("adding %u to array would overflow", len); ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1498| | 1499| 80.1k| if ((array->len + len) > array->alloc) ------------------ | Branch (1499:7): [True: 21.7k, False: 58.4k] ------------------ 1500| 21.7k| { 1501| 21.7k| guint old_alloc = array->alloc; 1502| 21.7k| array->alloc = g_nearest_pow (array->len + len); 1503| 21.7k| array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE); ------------------ | | 822| 21.7k|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 1.79k, False: 19.9k] | | ------------------ ------------------ 1504| 21.7k| array->pdata = g_realloc (array->pdata, sizeof (gpointer) * array->alloc); 1505| 21.7k| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 21.7k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 21.7k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 21.7k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 21.7k| int _g_boolean_var_; \ | | | | 1018| 21.7k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 21.7k] | | | | ------------------ | | | | 1019| 21.7k| _g_boolean_var_ = 1; \ | | | | 1020| 21.7k| else \ | | | | 1021| 21.7k| _g_boolean_var_ = 0; \ | | | | 1022| 21.7k| _g_boolean_var_; \ | | | | 1023| 21.7k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 21.7k] | | ------------------ ------------------ 1506| 0| for ( ; old_alloc < array->alloc; old_alloc++) ------------------ | Branch (1506:17): [True: 0, False: 0] ------------------ 1507| 0| array->pdata [old_alloc] = NULL; 1508| 21.7k| } 1509| 80.1k|} g_pointer_bit_lock: 402| 61.6k|{ 403| 61.6k| g_return_if_fail (lock_bit < 32); ------------------ | | 630| 61.6k| G_STMT_START { \ | | ------------------ | | | | 874| 61.6k|#define G_STMT_START do | | ------------------ | | 631| 61.6k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 61.6k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 61.6k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 61.6k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 61.6k| int _g_boolean_var_; \ | | | | | | 1018| 61.6k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 61.6k, False: 0] | | | | | | ------------------ | | | | | | 1019| 61.6k| _g_boolean_var_ = 1; \ | | | | | | 1020| 61.6k| else \ | | | | | | 1021| 61.6k| _g_boolean_var_ = 0; \ | | | | | | 1022| 61.6k| _g_boolean_var_; \ | | | | | | 1023| 61.6k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 61.6k, False: 0] | | | | ------------------ | | ------------------ | | 632| 61.6k| { } \ | | 633| 61.6k| else \ | | 634| 61.6k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 61.6k| } G_STMT_END | | ------------------ | | | | 882| 61.6k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 61.6k] | | | | ------------------ | | ------------------ ------------------ 404| | 405| 61.6k| { 406| |#ifdef USE_ASM_GOTO 407| | retry: 408| | __asm__ volatile goto ("lock bts %1, (%0)\n" 409| | "jc %l[contended]" 410| | : /* no output */ 411| | : "r" (address), "r" ((gsize) lock_bit) 412| | : "cc", "memory" 413| | : contended); 414| | return; 415| | 416| | contended: 417| | { 418| | volatile gsize *pointer_address = address; 419| | gsize mask = 1u << lock_bit; 420| | gsize v; 421| | 422| | v = (gsize) g_atomic_pointer_get (pointer_address); 423| | if (v & mask) 424| | { 425| | guint class = ((gsize) address) % G_N_ELEMENTS (g_bit_lock_contended); 426| | 427| | g_atomic_int_add (&g_bit_lock_contended[class], +1); 428| | g_futex_wait (g_futex_int_address (address), v); 429| | g_atomic_int_add (&g_bit_lock_contended[class], -1); 430| | } 431| | } 432| | goto retry; 433| |#else 434| 61.6k| volatile gsize *pointer_address = address; 435| 61.6k| gsize mask = 1u << lock_bit; 436| 61.6k| gsize v; 437| | 438| 61.6k| retry: 439| 61.6k| v = g_atomic_pointer_or (pointer_address, mask); ------------------ | | 235| 61.6k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 61.6k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 236| 61.6k| gsize *gapo_atomic = (gsize *) (atomic); \ | | 237| 61.6k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 61.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 238| 61.6k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gsize)); \ | | ------------------ | | | | 765| 61.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 239| 61.6k| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | ------------------ | | | Branch (239:13): [Folded, False: 61.6k] | | ------------------ | | 240| 61.6k| (void) (0 ? (val) ^ (val) : 1); \ | | ------------------ | | | Branch (240:13): [Folded, False: 61.6k] | | ------------------ | | 241| 61.6k| (gsize) __atomic_fetch_or (gapo_atomic, (val), __ATOMIC_SEQ_CST); \ | | 242| 61.6k| })) ------------------ 440| 61.6k| if (v & mask) ------------------ | Branch (440:7): [True: 0, False: 61.6k] ------------------ 441| | /* already locked */ 442| 0| { 443| 0| guint class = ((gsize) address) % G_N_ELEMENTS (g_bit_lock_contended); ------------------ | | 840| 0|#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) ------------------ 444| | 445| 0| g_atomic_int_add (&g_bit_lock_contended[class], +1); ------------------ | | 167| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 168| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 169| 0| (void) (0 ? *(atomic) ^ (val) : 1); \ | | ------------------ | | | Branch (169:13): [Folded, False: 0] | | ------------------ | | 170| 0| (gint) __atomic_fetch_add ((atomic), (val), __ATOMIC_SEQ_CST); \ | | 171| 0| })) ------------------ 446| 0| g_futex_wait (g_futex_int_address (address), (guint) v); 447| 0| g_atomic_int_add (&g_bit_lock_contended[class], -1); ------------------ | | 167| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 168| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 169| 0| (void) (0 ? *(atomic) ^ (val) : 1); \ | | ------------------ | | | Branch (169:13): [Folded, False: 0] | | ------------------ | | 170| 0| (gint) __atomic_fetch_add ((atomic), (val), __ATOMIC_SEQ_CST); \ | | 171| 0| })) ------------------ 448| | 449| 0| goto retry; 450| 0| } 451| 61.6k|#endif 452| 61.6k| } 453| 61.6k|} g_pointer_bit_unlock: 518| 61.6k|{ 519| 61.6k| g_return_if_fail (lock_bit < 32); ------------------ | | 630| 61.6k| G_STMT_START { \ | | ------------------ | | | | 874| 61.6k|#define G_STMT_START do | | ------------------ | | 631| 61.6k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 61.6k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 61.6k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 61.6k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 61.6k| int _g_boolean_var_; \ | | | | | | 1018| 61.6k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 61.6k, False: 0] | | | | | | ------------------ | | | | | | 1019| 61.6k| _g_boolean_var_ = 1; \ | | | | | | 1020| 61.6k| else \ | | | | | | 1021| 61.6k| _g_boolean_var_ = 0; \ | | | | | | 1022| 61.6k| _g_boolean_var_; \ | | | | | | 1023| 61.6k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 61.6k, False: 0] | | | | ------------------ | | ------------------ | | 632| 61.6k| { } \ | | 633| 61.6k| else \ | | 634| 61.6k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 61.6k| } G_STMT_END | | ------------------ | | | | 882| 61.6k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 61.6k] | | | | ------------------ | | ------------------ ------------------ 520| | 521| 61.6k| { 522| |#ifdef USE_ASM_GOTO 523| | __asm__ volatile ("lock btr %1, (%0)" 524| | : /* no output */ 525| | : "r" (address), "r" ((gsize) lock_bit) 526| | : "cc", "memory"); 527| |#else 528| 61.6k| volatile gsize *pointer_address = address; 529| 61.6k| gsize mask = 1u << lock_bit; 530| | 531| 61.6k| g_atomic_pointer_and (pointer_address, ~mask); ------------------ | | 226| 61.6k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 61.6k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 227| 61.6k| gsize *gapa_atomic = (gsize *) (atomic); \ | | 228| 61.6k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 61.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 229| 61.6k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gsize)); \ | | ------------------ | | | | 765| 61.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 230| 61.6k| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | ------------------ | | | Branch (230:13): [Folded, False: 61.6k] | | ------------------ | | 231| 61.6k| (void) (0 ? (val) ^ (val) : 1); \ | | ------------------ | | | Branch (231:13): [Folded, False: 61.6k] | | ------------------ | | 232| 61.6k| (gsize) __atomic_fetch_and (gapa_atomic, (val), __ATOMIC_SEQ_CST); \ | | 233| 61.6k| })) ------------------ 532| 61.6k|#endif 533| | 534| 61.6k| { 535| 61.6k| guint class = ((gsize) address) % G_N_ELEMENTS (g_bit_lock_contended); ------------------ | | 840| 61.6k|#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) ------------------ 536| 61.6k| if (g_atomic_int_get (&g_bit_lock_contended[class])) ------------------ | | 96| 61.6k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 61.6k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | | Branch (96:3): [True: 0, False: 61.6k] | | ------------------ | | 97| 61.6k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 61.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 61.6k| gint gaig_temp; \ | | 99| 61.6k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 61.6k] | | ------------------ | | 100| 61.6k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 61.6k| (gint) gaig_temp; \ | | 102| 61.6k| })) ------------------ 537| 0| g_futex_wake (g_futex_int_address (address)); 538| 61.6k| } 539| 61.6k| } 540| 61.6k|} gsignal.c:g_bsearch_array_create: 123| 3|{ 124| 3| GBSearchArray *barray; 125| 3| guint size; 126| | 127| 3| g_return_val_if_fail (bconfig != NULL, NULL); ------------------ | | 643| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 644| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 645| 3| { } \ | | 646| 3| else \ | | 647| 3| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 128| | 129| 3| size = sizeof (GBSearchArray) + bconfig->sizeof_node; 130| 3| if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2) ------------------ | Branch (130:7): [True: 2, False: 1] ------------------ 131| 2| size = G_BSEARCH_UPPER_POWER2 (size); ------------------ | | 119| 2|#define G_BSEARCH_UPPER_POWER2(n) ((n) ? 1 << g_bit_storage ((n) - 1) : 0) | | ------------------ | | | | 370| 2|#define g_bit_storage(number) g_bit_storage_impl(number) | | ------------------ | | | Branch (119:42): [True: 2, False: 0] | | ------------------ ------------------ 132| 3| barray = (GBSearchArray *) g_malloc (size); 133| 3| memset (barray, 0, sizeof (GBSearchArray)); 134| | 135| 3| return barray; 136| 3|} gsignal.c:g_bsearch_array_lookup_fuzzy: 147| 1|{ 148| 1| GBSearchCompareFunc cmp_nodes = bconfig->cmp_nodes; 149| 1| guint8 *check = NULL, *nodes = G_BSEARCH_ARRAY_NODES (barray); ------------------ | | 120| 1|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 150| 1| guint n_nodes = barray->n_nodes, offs = 0; 151| 1| guint sizeof_node = bconfig->sizeof_node; 152| 1| gint cmp = 0; 153| | 154| 1| while (offs < n_nodes) ------------------ | Branch (154:10): [True: 0, False: 1] ------------------ 155| 0| { 156| 0| guint i = (offs + n_nodes) >> 1; 157| | 158| 0| check = nodes + i * sizeof_node; 159| 0| cmp = cmp_nodes (key_node, check); 160| 0| if (cmp == 0) ------------------ | Branch (160:11): [True: 0, False: 0] ------------------ 161| 0| return sibling_or_after > 1 ? NULL : check; ------------------ | Branch (161:16): [True: 0, False: 0] ------------------ 162| 0| else if (cmp < 0) ------------------ | Branch (162:16): [True: 0, False: 0] ------------------ 163| 0| n_nodes = i; 164| 0| else /* (cmp > 0) */ 165| 0| offs = i + 1; 166| 0| } 167| | 168| | /* check is last mismatch, cmp > 0 indicates greater key */ 169| 1| return G_LIKELY (!sibling_or_after) ? NULL : (sibling_or_after > 1 && cmp > 0) ? check + sizeof_node : check; ------------------ | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 1| int _g_boolean_var_; \ | | | | 1018| 1| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 1, False: 0] | | | | ------------------ | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | 1020| 1| else \ | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | 1022| 1| _g_boolean_var_; \ | | | | 1023| 1|}) | | ------------------ | | | Branch (1024:24): [True: 1, False: 0] | | ------------------ ------------------ | Branch (169:49): [True: 0, False: 0] | Branch (169:73): [True: 0, False: 0] ------------------ 170| 1|} gsignal.c:g_bsearch_array_get_nth: 175| 1|{ 176| 1| return (G_LIKELY (nth < barray->n_nodes) ? ------------------ | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 1| int _g_boolean_var_; \ | | | | 1018| 1| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 1, False: 0] | | | | ------------------ | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | 1020| 1| else \ | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | 1022| 1| _g_boolean_var_; \ | | | | 1023| 1|}) | | ------------------ | | | Branch (1024:24): [True: 1, False: 0] | | ------------------ ------------------ 177| 1| G_BSEARCH_ARRAY_NODES (barray) + nth * bconfig->sizeof_node : ------------------ | | 120| 1|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 178| | NULL); 179| 1|} gsignal.c:g_bsearch_array_insert: 222| 2|{ 223| 2| guint8 *node; 224| | 225| 2| if (G_UNLIKELY (!barray->n_nodes)) ------------------ | | 1025| 2|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2| int _g_boolean_var_; \ | | | | 1018| 2| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 2, False: 0] | | | | ------------------ | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | 1020| 2| else \ | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | 1022| 2| _g_boolean_var_; \ | | | | 1023| 2|}) | | ------------------ | | | Branch (1025:26): [True: 2, False: 0] | | ------------------ ------------------ 226| 2| { 227| 2| barray = g_bsearch_array_grow (barray, bconfig, 0); 228| 2| node = G_BSEARCH_ARRAY_NODES (barray); ------------------ | | 120| 2|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 229| 2| } 230| 0| else 231| 0| { 232| 0| node = (guint8 *) g_bsearch_array_lookup_insertion (barray, bconfig, key_node); ------------------ | | 114| 0| g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 2) ------------------ 233| 0| if (G_LIKELY (node)) ------------------ | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1024:24): [True: 0, False: 0] | | ------------------ ------------------ 234| 0| { 235| 0| guint index_ = g_bsearch_array_get_index (barray, bconfig, node); 236| | 237| | /* grow and insert */ 238| 0| barray = g_bsearch_array_grow (barray, bconfig, index_); 239| 0| node = G_BSEARCH_ARRAY_NODES (barray) + index_ * bconfig->sizeof_node; ------------------ | | 120| 0|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 240| 0| } 241| 0| else /* no insertion needed, node already there */ 242| 0| return barray; 243| 0| } 244| 2| memcpy (node, key_node, bconfig->sizeof_node); 245| 2| return barray; 246| 2|} gsignal.c:g_bsearch_array_grow: 197| 2|{ 198| 2| guint old_size = barray->n_nodes * bconfig->sizeof_node; 199| 2| guint new_size = old_size + bconfig->sizeof_node; 200| 2| guint8 *node; 201| | 202| 2| g_return_val_if_fail (index_ <= barray->n_nodes, NULL); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 203| | 204| 2| if (G_UNLIKELY (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2)) ------------------ | | 1025| 2|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2| int _g_boolean_var_; \ | | | | 1018| 2| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 1, False: 1] | | | | ------------------ | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | 1020| 2| else \ | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | 1022| 2| _g_boolean_var_; \ | | | | 1023| 2|}) | | ------------------ | | | Branch (1025:26): [True: 1, False: 1] | | ------------------ ------------------ 205| 1| { 206| 1| new_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + new_size); ------------------ | | 119| 1|#define G_BSEARCH_UPPER_POWER2(n) ((n) ? 1 << g_bit_storage ((n) - 1) : 0) | | ------------------ | | | | 370| 1|#define g_bit_storage(number) g_bit_storage_impl(number) | | ------------------ | | | Branch (119:42): [True: 1, False: 0] | | ------------------ ------------------ 207| 1| old_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + old_size); ------------------ | | 119| 1|#define G_BSEARCH_UPPER_POWER2(n) ((n) ? 1 << g_bit_storage ((n) - 1) : 0) | | ------------------ | | | | 370| 1|#define g_bit_storage(number) g_bit_storage_impl(number) | | ------------------ | | | Branch (119:42): [True: 1, False: 0] | | ------------------ ------------------ 208| 1| if (old_size != new_size) ------------------ | Branch (208:11): [True: 1, False: 0] ------------------ 209| 1| barray = (GBSearchArray *) g_realloc (barray, new_size); 210| 1| } 211| 1| else 212| 1| barray = (GBSearchArray *) g_realloc (barray, sizeof (GBSearchArray) + new_size); 213| 2| node = G_BSEARCH_ARRAY_NODES (barray) + index_ * bconfig->sizeof_node; ------------------ | | 120| 2|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 214| 2| memmove (node + bconfig->sizeof_node, node, (barray->n_nodes - index_) * bconfig->sizeof_node); 215| 2| barray->n_nodes += 1; 216| 2| return barray; 217| 2|} gvalue.c:g_bsearch_array_create: 123| 2|{ 124| 2| GBSearchArray *barray; 125| 2| guint size; 126| | 127| 2| g_return_val_if_fail (bconfig != NULL, NULL); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 128| | 129| 2| size = sizeof (GBSearchArray) + bconfig->sizeof_node; 130| 2| if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2) ------------------ | Branch (130:7): [True: 2, False: 0] ------------------ 131| 2| size = G_BSEARCH_UPPER_POWER2 (size); ------------------ | | 119| 2|#define G_BSEARCH_UPPER_POWER2(n) ((n) ? 1 << g_bit_storage ((n) - 1) : 0) | | ------------------ | | | | 370| 2|#define g_bit_storage(number) g_bit_storage_impl(number) | | ------------------ | | | Branch (119:42): [True: 2, False: 0] | | ------------------ ------------------ 132| 2| barray = (GBSearchArray *) g_malloc (size); 133| 2| memset (barray, 0, sizeof (GBSearchArray)); 134| | 135| 2| return barray; 136| 2|} gvalue.c:g_bsearch_array_replace: 251| 340|{ 252| 340| guint8 *node = (guint8 *) g_bsearch_array_lookup (barray, bconfig, key_node); ------------------ | | 97| 340| g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 0) ------------------ 253| 340| if (G_LIKELY (node)) /* expected path */ ------------------ | | 1024| 340|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 340| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 340|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 340| int _g_boolean_var_; \ | | | | 1018| 340| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 340] | | | | ------------------ | | | | 1019| 340| _g_boolean_var_ = 1; \ | | | | 1020| 340| else \ | | | | 1021| 340| _g_boolean_var_ = 0; \ | | | | 1022| 340| _g_boolean_var_; \ | | | | 1023| 340|}) | | ------------------ | | | Branch (1024:24): [True: 0, False: 340] | | ------------------ ------------------ 254| 0| memcpy (node, key_node, bconfig->sizeof_node); 255| 340| else /* revert to insertion */ 256| 340| barray = g_bsearch_array_insert (barray, bconfig, key_node); 257| 340| return barray; 258| 340|} gvalue.c:g_bsearch_array_lookup_fuzzy: 147| 678|{ 148| 678| GBSearchCompareFunc cmp_nodes = bconfig->cmp_nodes; 149| 678| guint8 *check = NULL, *nodes = G_BSEARCH_ARRAY_NODES (barray); ------------------ | | 120| 678|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 150| 678| guint n_nodes = barray->n_nodes, offs = 0; 151| 678| guint sizeof_node = bconfig->sizeof_node; 152| 678| gint cmp = 0; 153| | 154| 4.70k| while (offs < n_nodes) ------------------ | Branch (154:10): [True: 4.02k, False: 678] ------------------ 155| 4.02k| { 156| 4.02k| guint i = (offs + n_nodes) >> 1; 157| | 158| 4.02k| check = nodes + i * sizeof_node; 159| 4.02k| cmp = cmp_nodes (key_node, check); 160| 4.02k| if (cmp == 0) ------------------ | Branch (160:11): [True: 0, False: 4.02k] ------------------ 161| 0| return sibling_or_after > 1 ? NULL : check; ------------------ | Branch (161:16): [True: 0, False: 0] ------------------ 162| 4.02k| else if (cmp < 0) ------------------ | Branch (162:16): [True: 924, False: 3.10k] ------------------ 163| 924| n_nodes = i; 164| 3.10k| else /* (cmp > 0) */ 165| 3.10k| offs = i + 1; 166| 4.02k| } 167| | 168| | /* check is last mismatch, cmp > 0 indicates greater key */ 169| 678| return G_LIKELY (!sibling_or_after) ? NULL : (sibling_or_after > 1 && cmp > 0) ? check + sizeof_node : check; ------------------ | | 1024| 678|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 678| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 678|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 678| int _g_boolean_var_; \ | | | | 1018| 678| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 340, False: 338] | | | | ------------------ | | | | 1019| 678| _g_boolean_var_ = 1; \ | | | | 1020| 678| else \ | | | | 1021| 678| _g_boolean_var_ = 0; \ | | | | 1022| 678| _g_boolean_var_; \ | | | | 1023| 678|}) | | ------------------ | | | Branch (1024:24): [True: 340, False: 338] | | ------------------ ------------------ | Branch (169:49): [True: 338, False: 0] | Branch (169:73): [True: 212, False: 126] ------------------ 170| 678|} gvalue.c:g_bsearch_array_insert: 222| 340|{ 223| 340| guint8 *node; 224| | 225| 340| if (G_UNLIKELY (!barray->n_nodes)) ------------------ | | 1025| 340|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 340| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 340|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 340| int _g_boolean_var_; \ | | | | 1018| 340| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 2, False: 338] | | | | ------------------ | | | | 1019| 340| _g_boolean_var_ = 1; \ | | | | 1020| 340| else \ | | | | 1021| 340| _g_boolean_var_ = 0; \ | | | | 1022| 340| _g_boolean_var_; \ | | | | 1023| 340|}) | | ------------------ | | | Branch (1025:26): [True: 2, False: 338] | | ------------------ ------------------ 226| 2| { 227| 2| barray = g_bsearch_array_grow (barray, bconfig, 0); 228| 2| node = G_BSEARCH_ARRAY_NODES (barray); ------------------ | | 120| 2|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 229| 2| } 230| 338| else 231| 338| { 232| 338| node = (guint8 *) g_bsearch_array_lookup_insertion (barray, bconfig, key_node); ------------------ | | 114| 338| g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 2) ------------------ 233| 338| if (G_LIKELY (node)) ------------------ | | 1024| 338|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 338| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 338|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 338| int _g_boolean_var_; \ | | | | 1018| 338| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 338, False: 0] | | | | ------------------ | | | | 1019| 338| _g_boolean_var_ = 1; \ | | | | 1020| 338| else \ | | | | 1021| 338| _g_boolean_var_ = 0; \ | | | | 1022| 338| _g_boolean_var_; \ | | | | 1023| 338|}) | | ------------------ | | | Branch (1024:24): [True: 338, False: 0] | | ------------------ ------------------ 234| 338| { 235| 338| guint index_ = g_bsearch_array_get_index (barray, bconfig, node); 236| | 237| | /* grow and insert */ 238| 338| barray = g_bsearch_array_grow (barray, bconfig, index_); 239| 338| node = G_BSEARCH_ARRAY_NODES (barray) + index_ * bconfig->sizeof_node; ------------------ | | 120| 338|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 240| 338| } 241| 0| else /* no insertion needed, node already there */ 242| 0| return barray; 243| 338| } 244| 340| memcpy (node, key_node, bconfig->sizeof_node); 245| 340| return barray; 246| 340|} gvalue.c:g_bsearch_array_grow: 197| 340|{ 198| 340| guint old_size = barray->n_nodes * bconfig->sizeof_node; 199| 340| guint new_size = old_size + bconfig->sizeof_node; 200| 340| guint8 *node; 201| | 202| 340| g_return_val_if_fail (index_ <= barray->n_nodes, NULL); ------------------ | | 643| 340| G_STMT_START { \ | | ------------------ | | | | 874| 340|#define G_STMT_START do | | ------------------ | | 644| 340| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 340|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 340| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 340|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 340| int _g_boolean_var_; \ | | | | | | 1018| 340| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 340, False: 0] | | | | | | ------------------ | | | | | | 1019| 340| _g_boolean_var_ = 1; \ | | | | | | 1020| 340| else \ | | | | | | 1021| 340| _g_boolean_var_ = 0; \ | | | | | | 1022| 340| _g_boolean_var_; \ | | | | | | 1023| 340|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 340, False: 0] | | | | ------------------ | | ------------------ | | 645| 340| { } \ | | 646| 340| else \ | | 647| 340| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 340| } G_STMT_END | | ------------------ | | | | 882| 340|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 340] | | | | ------------------ | | ------------------ ------------------ 203| | 204| 340| if (G_UNLIKELY (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2)) ------------------ | | 1025| 340|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 340| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 340|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 340| int _g_boolean_var_; \ | | | | 1018| 340| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 340, False: 0] | | | | ------------------ | | | | 1019| 340| _g_boolean_var_ = 1; \ | | | | 1020| 340| else \ | | | | 1021| 340| _g_boolean_var_ = 0; \ | | | | 1022| 340| _g_boolean_var_; \ | | | | 1023| 340|}) | | ------------------ | | | Branch (1025:26): [True: 340, False: 0] | | ------------------ ------------------ 205| 340| { 206| 340| new_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + new_size); ------------------ | | 119| 340|#define G_BSEARCH_UPPER_POWER2(n) ((n) ? 1 << g_bit_storage ((n) - 1) : 0) | | ------------------ | | | | 370| 340|#define g_bit_storage(number) g_bit_storage_impl(number) | | ------------------ | | | Branch (119:42): [True: 340, False: 0] | | ------------------ ------------------ 207| 340| old_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + old_size); ------------------ | | 119| 340|#define G_BSEARCH_UPPER_POWER2(n) ((n) ? 1 << g_bit_storage ((n) - 1) : 0) | | ------------------ | | | | 370| 340|#define g_bit_storage(number) g_bit_storage_impl(number) | | ------------------ | | | Branch (119:42): [True: 340, False: 0] | | ------------------ ------------------ 208| 340| if (old_size != new_size) ------------------ | Branch (208:11): [True: 16, False: 324] ------------------ 209| 16| barray = (GBSearchArray *) g_realloc (barray, new_size); 210| 340| } 211| 0| else 212| 0| barray = (GBSearchArray *) g_realloc (barray, sizeof (GBSearchArray) + new_size); 213| 340| node = G_BSEARCH_ARRAY_NODES (barray) + index_ * bconfig->sizeof_node; ------------------ | | 120| 340|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 214| 340| memmove (node + bconfig->sizeof_node, node, (barray->n_nodes - index_) * bconfig->sizeof_node); 215| 340| barray->n_nodes += 1; 216| 340| return barray; 217| 340|} gvalue.c:g_bsearch_array_get_index: 184| 338|{ 185| 338| guint distance = ((guint8*) node_in_array) - G_BSEARCH_ARRAY_NODES (barray); ------------------ | | 120| 338|#define G_BSEARCH_ARRAY_NODES(barray) (((guint8*) (barray)) + sizeof (GBSearchArray)) ------------------ 186| | 187| 338| g_return_val_if_fail (node_in_array != NULL, barray->n_nodes); ------------------ | | 643| 338| G_STMT_START { \ | | ------------------ | | | | 874| 338|#define G_STMT_START do | | ------------------ | | 644| 338| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 338|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 338| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 338|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 338| int _g_boolean_var_; \ | | | | | | 1018| 338| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 338, False: 0] | | | | | | ------------------ | | | | | | 1019| 338| _g_boolean_var_ = 1; \ | | | | | | 1020| 338| else \ | | | | | | 1021| 338| _g_boolean_var_ = 0; \ | | | | | | 1022| 338| _g_boolean_var_; \ | | | | | | 1023| 338|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 338, False: 0] | | | | ------------------ | | ------------------ | | 645| 338| { } \ | | 646| 338| else \ | | 647| 338| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 338| } G_STMT_END | | ------------------ | | | | 882| 338|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 338] | | | | ------------------ | | ------------------ ------------------ 188| | 189| 338| distance /= bconfig->sizeof_node; 190| | 191| 338| return MIN (distance, barray->n_nodes + 1); /* may return one after end */ ------------------ | | 825| 338|#define MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (825:21): [True: 338, False: 0] | | ------------------ ------------------ 192| 338|} g_bytes_new: 95| 807|{ 96| 807| g_return_val_if_fail (data != NULL || size == 0, NULL); ------------------ | | 643| 807| G_STMT_START { \ | | ------------------ | | | | 874| 807|#define G_STMT_START do | | ------------------ | | 644| 807| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 807|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 807| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 807|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 807| int _g_boolean_var_; \ | | | | | | 1018| 1.61k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 807, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 807| _g_boolean_var_ = 1; \ | | | | | | 1020| 807| else \ | | | | | | 1021| 807| _g_boolean_var_ = 0; \ | | | | | | 1022| 807| _g_boolean_var_; \ | | | | | | 1023| 807|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 807, False: 0] | | | | ------------------ | | ------------------ | | 645| 807| { } \ | | 646| 807| else \ | | 647| 807| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 807| } G_STMT_END | | ------------------ | | | | 882| 807|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 807] | | | | ------------------ | | ------------------ ------------------ 97| | 98| 807| return g_bytes_new_take (g_memdup2 (data, size), size); 99| 807|} g_bytes_new_take: 127| 3.71k|{ 128| 3.71k| return g_bytes_new_with_free_func (data, size, g_free, data); 129| 3.71k|} g_bytes_new_static: 150| 3.85k|{ 151| 3.85k| return g_bytes_new_with_free_func (data, size, NULL, NULL); 152| 3.85k|} g_bytes_new_with_free_func: 181| 7.57k|{ 182| 7.57k| GBytes *bytes; 183| | 184| 7.57k| g_return_val_if_fail (data != NULL || size == 0, NULL); ------------------ | | 643| 7.57k| G_STMT_START { \ | | ------------------ | | | | 874| 7.57k|#define G_STMT_START do | | ------------------ | | 644| 7.57k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.57k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.57k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.57k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.57k| int _g_boolean_var_; \ | | | | | | 1018| 15.1k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.57k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.57k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.57k| else \ | | | | | | 1021| 7.57k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.57k| _g_boolean_var_; \ | | | | | | 1023| 7.57k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.57k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.57k| { } \ | | 646| 7.57k| else \ | | 647| 7.57k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.57k| } G_STMT_END | | ------------------ | | | | 882| 7.57k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.57k] | | | | ------------------ | | ------------------ ------------------ 185| | 186| 7.57k| bytes = g_slice_new (GBytes); ------------------ | | 46| 7.57k|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) ------------------ 187| 7.57k| bytes->data = data; 188| 7.57k| bytes->size = size; 189| 7.57k| bytes->free_func = free_func; 190| 7.57k| bytes->user_data = user_data; 191| 7.57k| g_atomic_ref_count_init (&bytes->ref_count); 192| | 193| 7.57k| return (GBytes *)bytes; 194| 7.57k|} g_bytes_get_data: 272| 120k|{ 273| 120k| g_return_val_if_fail (bytes != NULL, NULL); ------------------ | | 643| 120k| G_STMT_START { \ | | ------------------ | | | | 874| 120k|#define G_STMT_START do | | ------------------ | | 644| 120k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 120k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 120k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 120k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 120k| int _g_boolean_var_; \ | | | | | | 1018| 120k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 120k, False: 0] | | | | | | ------------------ | | | | | | 1019| 120k| _g_boolean_var_ = 1; \ | | | | | | 1020| 120k| else \ | | | | | | 1021| 120k| _g_boolean_var_ = 0; \ | | | | | | 1022| 120k| _g_boolean_var_; \ | | | | | | 1023| 120k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 120k, False: 0] | | | | ------------------ | | ------------------ | | 645| 120k| { } \ | | 646| 120k| else \ | | 647| 120k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 120k| } G_STMT_END | | ------------------ | | | | 882| 120k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 120k] | | | | ------------------ | | ------------------ ------------------ 274| 120k| if (size) ------------------ | Branch (274:7): [True: 119k, False: 652] ------------------ 275| 119k| *size = bytes->size; 276| 120k| return bytes->data; 277| 120k|} g_bytes_get_size: 293| 125k|{ 294| 125k| g_return_val_if_fail (bytes != NULL, 0); ------------------ | | 643| 125k| G_STMT_START { \ | | ------------------ | | | | 874| 125k|#define G_STMT_START do | | ------------------ | | 644| 125k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 125k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 125k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 125k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 125k| int _g_boolean_var_; \ | | | | | | 1018| 125k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 125k, False: 0] | | | | | | ------------------ | | | | | | 1019| 125k| _g_boolean_var_ = 1; \ | | | | | | 1020| 125k| else \ | | | | | | 1021| 125k| _g_boolean_var_ = 0; \ | | | | | | 1022| 125k| _g_boolean_var_; \ | | | | | | 1023| 125k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 125k, False: 0] | | | | ------------------ | | ------------------ | | 645| 125k| { } \ | | 646| 125k| else \ | | 647| 125k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 125k| } G_STMT_END | | ------------------ | | | | 882| 125k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 125k] | | | | ------------------ | | ------------------ ------------------ 295| 125k| return bytes->size; 296| 125k|} g_bytes_ref: 311| 7.86k|{ 312| 7.86k| g_return_val_if_fail (bytes != NULL, NULL); ------------------ | | 643| 7.86k| G_STMT_START { \ | | ------------------ | | | | 874| 7.86k|#define G_STMT_START do | | ------------------ | | 644| 7.86k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.86k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.86k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.86k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.86k| int _g_boolean_var_; \ | | | | | | 1018| 7.86k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.86k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.86k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.86k| else \ | | | | | | 1021| 7.86k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.86k| _g_boolean_var_; \ | | | | | | 1023| 7.86k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.86k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.86k| { } \ | | 646| 7.86k| else \ | | 647| 7.86k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.86k| } G_STMT_END | | ------------------ | | | | 882| 7.86k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.86k] | | | | ------------------ | | ------------------ ------------------ 313| | 314| 7.86k| g_atomic_ref_count_inc (&bytes->ref_count); 315| | 316| 7.86k| return bytes; 317| 7.86k|} g_bytes_unref: 330| 15.4k|{ 331| 15.4k| if (bytes == NULL) ------------------ | Branch (331:7): [True: 0, False: 15.4k] ------------------ 332| 0| return; 333| | 334| 15.4k| if (g_atomic_ref_count_dec (&bytes->ref_count)) ------------------ | Branch (334:7): [True: 7.57k, False: 7.86k] ------------------ 335| 7.57k| { 336| 7.57k| if (bytes->free_func != NULL) ------------------ | Branch (336:11): [True: 3.71k, False: 3.85k] ------------------ 337| 3.71k| bytes->free_func (bytes->user_data); 338| 7.57k| g_slice_free (GBytes, bytes); ------------------ | | 79| 7.57k|#define g_slice_free(type, mem) \ | | ------------------ | | | | 874| 7.57k|#define G_STMT_START do | | ------------------ | | 80| 7.57k|G_STMT_START { \ | | 81| 7.57k| if (1) g_slice_free1 (sizeof (type), (mem)); \ | | ------------------ | | | Branch (81:7): [True: 7.57k, Folded] | | ------------------ | | 82| 7.57k| else (void) ((type*) 0 == (mem)); \ | | 83| 7.57k|} G_STMT_END | | ------------------ | | | | 882| 7.57k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.57k] | | | | ------------------ | | ------------------ ------------------ 339| 7.57k| } 340| 15.4k|} g_datalist_clear: 255| 7.70k|{ 256| 7.70k| GData *data; 257| 7.70k| guint i; 258| | 259| 7.70k| g_return_if_fail (datalist != NULL); ------------------ | | 630| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 631| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 632| 7.70k| { } \ | | 633| 7.70k| else \ | | 634| 7.70k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 260| | 261| 7.70k| g_datalist_lock (datalist); 262| | 263| 7.70k| data = G_DATALIST_GET_POINTER (datalist); ------------------ | | 142| 7.70k| ((GData*) ((gsize) g_atomic_pointer_get (datalist) & ~(gsize) G_DATALIST_FLAGS_MASK_INTERNAL)) | | ------------------ | | | | 113| 7.70k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 7.70k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 7.70k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 7.70k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 7.70k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 7.70k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 7.70k| gapg_temp_newval; \ | | | | 119| 7.70k| })) | | ------------------ | | ((GData*) ((gsize) g_atomic_pointer_get (datalist) & ~(gsize) G_DATALIST_FLAGS_MASK_INTERNAL)) | | ------------------ | | | | 138| 7.70k|#define G_DATALIST_FLAGS_MASK_INTERNAL 0x7 | | ------------------ ------------------ 264| 7.70k| G_DATALIST_SET_POINTER (datalist, NULL); ------------------ | | 144| 7.70k|#define G_DATALIST_SET_POINTER(datalist, pointer) G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 145| 7.70k| gpointer _oldv, _newv; \ | | 146| 7.70k| do { \ | | 147| 7.70k| _oldv = g_atomic_pointer_get (datalist); \ | | ------------------ | | | | 113| 7.70k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 7.70k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 7.70k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 7.70k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 7.70k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 7.70k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 7.70k| gapg_temp_newval; \ | | | | 119| 7.70k| })) | | ------------------ | | 148| 7.70k| _newv = (gpointer) (((gsize) _oldv & G_DATALIST_FLAGS_MASK_INTERNAL) | (gsize) pointer); \ | | ------------------ | | | | 138| 7.70k|#define G_DATALIST_FLAGS_MASK_INTERNAL 0x7 | | ------------------ | | 149| 7.70k| } while (!g_atomic_pointer_compare_and_exchange ((void**) datalist, _oldv, _newv)); \ | | ------------------ | | | | 210| 7.70k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 211| 7.70k| G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 212| 7.70k| gpointer gapcae_oldval = (gpointer)(oldval); \ | | | | 213| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 214| 7.70k| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | | | ------------------ | | | | | Branch (214:13): [Folded, False: 7.70k] | | | | ------------------ | | | | 215| 7.70k| __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 814| 7.70k|#define FALSE (0) | | | | ------------------ | | | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 818| 7.70k|#define TRUE (!FALSE) | | | | | | ------------------ | | | | | | | | 814| 7.70k|#define FALSE (0) | | | | | | ------------------ | | | | ------------------ | | | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 814| 0|#define FALSE (0) | | | | ------------------ | | | | | Branch (215:5): [True: 7.70k, False: 0] | | | | ------------------ | | | | 216| 7.70k| })) | | ------------------ | | | Branch (149:12): [True: 0, False: 7.70k] | | ------------------ | | 150| 7.70k|} G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 265| | 266| 7.70k| g_datalist_unlock (datalist); 267| | 268| 7.70k| if (data) ------------------ | Branch (268:7): [True: 0, False: 7.70k] ------------------ 269| 0| { 270| 0| for (i = 0; i < data->len; i++) ------------------ | Branch (270:19): [True: 0, False: 0] ------------------ 271| 0| { 272| 0| if (data->data[i].data && data->data[i].destroy) ------------------ | Branch (272:15): [True: 0, False: 0] | Branch (272:37): [True: 0, False: 0] ------------------ 273| 0| data->data[i].destroy (data->data[i].data); 274| 0| } 275| | 276| 0| g_free (data); 277| 0| } 278| 7.70k|} g_datalist_id_set_data_full: 658| 38.5k|{ 659| 38.5k| g_return_if_fail (datalist != NULL); ------------------ | | 630| 38.5k| G_STMT_START { \ | | ------------------ | | | | 874| 38.5k|#define G_STMT_START do | | ------------------ | | 631| 38.5k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 38.5k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 38.5k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 38.5k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 38.5k| int _g_boolean_var_; \ | | | | | | 1018| 38.5k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 38.5k, False: 0] | | | | | | ------------------ | | | | | | 1019| 38.5k| _g_boolean_var_ = 1; \ | | | | | | 1020| 38.5k| else \ | | | | | | 1021| 38.5k| _g_boolean_var_ = 0; \ | | | | | | 1022| 38.5k| _g_boolean_var_; \ | | | | | | 1023| 38.5k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 38.5k, False: 0] | | | | ------------------ | | ------------------ | | 632| 38.5k| { } \ | | 633| 38.5k| else \ | | 634| 38.5k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 38.5k| } G_STMT_END | | ------------------ | | | | 882| 38.5k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 38.5k] | | | | ------------------ | | ------------------ ------------------ 660| 38.5k| if (!data) ------------------ | Branch (660:7): [True: 34.6k, False: 3.85k] ------------------ 661| 38.5k| g_return_if_fail (destroy_func == NULL); ------------------ | | 630| 34.6k| G_STMT_START { \ | | ------------------ | | | | 874| 34.6k|#define G_STMT_START do | | ------------------ | | 631| 34.6k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 34.6k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 34.6k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 34.6k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 34.6k| int _g_boolean_var_; \ | | | | | | 1018| 34.6k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 34.6k, False: 0] | | | | | | ------------------ | | | | | | 1019| 34.6k| _g_boolean_var_ = 1; \ | | | | | | 1020| 34.6k| else \ | | | | | | 1021| 34.6k| _g_boolean_var_ = 0; \ | | | | | | 1022| 34.6k| _g_boolean_var_; \ | | | | | | 1023| 34.6k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 34.6k, False: 0] | | | | ------------------ | | ------------------ | | 632| 34.6k| { } \ | | 633| 34.6k| else \ | | 634| 34.6k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 34.6k| } G_STMT_END | | ------------------ | | | | 882| 34.6k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 34.6k] | | | | ------------------ | | ------------------ ------------------ 662| 38.5k| if (!key_id) ------------------ | Branch (662:7): [True: 0, False: 38.5k] ------------------ 663| 0| { 664| 0| if (data) ------------------ | Branch (664:11): [True: 0, False: 0] ------------------ 665| 0| g_return_if_fail (key_id > 0); ------------------ | | 630| 0| G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 631| 0| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 632| 0| { } \ | | 633| 0| else \ | | 634| 0| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 666| 0| else 667| 0| return; 668| 0| } 669| | 670| 38.5k| g_data_set_internal (datalist, key_id, data, destroy_func, NULL); 671| 38.5k|} g_datalist_id_get_data: 800| 15.4k|{ 801| 15.4k| return g_datalist_id_dup_data (datalist, key_id, NULL, NULL); 802| 15.4k|} g_datalist_id_dup_data: 850| 15.4k|{ 851| 15.4k| gpointer val = NULL; 852| 15.4k| gpointer retval = NULL; 853| 15.4k| GData *d; 854| 15.4k| GDataElt *data, *data_end; 855| | 856| 15.4k| g_datalist_lock (datalist); 857| | 858| 15.4k| d = G_DATALIST_GET_POINTER (datalist); ------------------ | | 142| 15.4k| ((GData*) ((gsize) g_atomic_pointer_get (datalist) & ~(gsize) G_DATALIST_FLAGS_MASK_INTERNAL)) | | ------------------ | | | | 113| 15.4k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 15.4k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 15.4k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 15.4k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 15.4k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 15.4k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 15.4k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 15.4k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 15.4k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 15.4k| gapg_temp_newval; \ | | | | 119| 15.4k| })) | | ------------------ | | ((GData*) ((gsize) g_atomic_pointer_get (datalist) & ~(gsize) G_DATALIST_FLAGS_MASK_INTERNAL)) | | ------------------ | | | | 138| 15.4k|#define G_DATALIST_FLAGS_MASK_INTERNAL 0x7 | | ------------------ ------------------ 859| 15.4k| if (d) ------------------ | Branch (859:7): [True: 3.85k, False: 11.5k] ------------------ 860| 3.85k| { 861| 3.85k| data = d->data; 862| 3.85k| data_end = data + d->len; 863| 3.85k| do 864| 3.85k| { 865| 3.85k| if (data->key == key_id) ------------------ | Branch (865:15): [True: 3.85k, False: 0] ------------------ 866| 3.85k| { 867| 3.85k| val = data->data; 868| 3.85k| break; 869| 3.85k| } 870| 0| data++; 871| 0| } 872| 3.85k| while (data < data_end); ------------------ | Branch (872:14): [True: 0, False: 0] ------------------ 873| 3.85k| } 874| | 875| 15.4k| if (dup_func) ------------------ | Branch (875:7): [True: 0, False: 15.4k] ------------------ 876| 0| retval = dup_func (val, user_data); 877| 15.4k| else 878| 15.4k| retval = val; 879| | 880| 15.4k| g_datalist_unlock (datalist); 881| | 882| 15.4k| return retval; 883| 15.4k|} g_datalist_set_flags: 1194| 1|{ 1195| 1| g_return_if_fail (datalist != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1196| 1| g_return_if_fail ((flags & ~G_DATALIST_FLAGS_MASK) == 0); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1197| | 1198| 1| g_atomic_pointer_or (datalist, (gsize)flags); ------------------ | | 235| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 236| 1| gsize *gapo_atomic = (gsize *) (atomic); \ | | 237| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 238| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gsize)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 239| 1| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | ------------------ | | | Branch (239:13): [Folded, False: 1] | | ------------------ | | 240| 1| (void) (0 ? (val) ^ (val) : 1); \ | | ------------------ | | | Branch (240:13): [Folded, False: 1] | | ------------------ | | 241| 1| (gsize) __atomic_fetch_or (gapo_atomic, (val), __ATOMIC_SEQ_CST); \ | | 242| 1| })) ------------------ 1199| 1|} g_datalist_get_flags: 1237| 11.5k|{ 1238| 11.5k| g_return_val_if_fail (datalist != NULL, 0); ------------------ | | 643| 11.5k| G_STMT_START { \ | | ------------------ | | | | 874| 11.5k|#define G_STMT_START do | | ------------------ | | 644| 11.5k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 11.5k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 11.5k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 11.5k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 11.5k| int _g_boolean_var_; \ | | | | | | 1018| 11.5k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 11.5k, False: 0] | | | | | | ------------------ | | | | | | 1019| 11.5k| _g_boolean_var_ = 1; \ | | | | | | 1020| 11.5k| else \ | | | | | | 1021| 11.5k| _g_boolean_var_ = 0; \ | | | | | | 1022| 11.5k| _g_boolean_var_; \ | | | | | | 1023| 11.5k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 11.5k, False: 0] | | | | ------------------ | | ------------------ | | 645| 11.5k| { } \ | | 646| 11.5k| else \ | | 647| 11.5k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 11.5k| } G_STMT_END | | ------------------ | | | | 882| 11.5k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 11.5k] | | | | ------------------ | | ------------------ ------------------ 1239| | 1240| 11.5k| return G_DATALIST_GET_FLAGS (datalist); /* atomic macro */ ------------------ | | 37| 11.5k| ((gsize) g_atomic_pointer_get (datalist) & G_DATALIST_FLAGS_MASK) | | ------------------ | | | | 113| 11.5k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 11.5k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 11.5k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 11.5k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 11.5k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 11.5k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 11.5k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 11.5k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 11.5k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 11.5k| gapg_temp_newval; \ | | | | 119| 11.5k| })) | | ------------------ | | ((gsize) g_atomic_pointer_get (datalist) & G_DATALIST_FLAGS_MASK) | | ------------------ | | | | 87| 11.5k|#define G_DATALIST_FLAGS_MASK 0x3 | | ------------------ ------------------ 1241| 11.5k|} gdataset.c:g_datalist_lock: 208| 61.6k|{ 209| 61.6k| g_pointer_bit_lock ((void **)datalist, DATALIST_LOCK_BIT); ------------------ | | 55| 61.6k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 61.6k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 56| 61.6k| G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 61.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 57| 61.6k| g_pointer_bit_lock ((address), (lock_bit)); \ | | 58| 61.6k| })) ------------------ 210| 61.6k|} gdataset.c:g_datalist_unlock: 214| 61.6k|{ 215| 61.6k| g_pointer_bit_unlock ((void **)datalist, DATALIST_LOCK_BIT); ------------------ | | 67| 61.6k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 61.6k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 68| 61.6k| G_STATIC_ASSERT (sizeof *(address) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 61.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 69| 61.6k| g_pointer_bit_unlock ((address), (lock_bit)); \ | | 70| 61.6k| })) ------------------ 216| 61.6k|} gdataset.c:g_data_set_internal: 350| 38.5k|{ 351| 38.5k| GData *d, *old_d; 352| 38.5k| GDataElt old, *data, *data_last, *data_end; 353| | 354| 38.5k| g_datalist_lock (datalist); 355| | 356| 38.5k| d = G_DATALIST_GET_POINTER (datalist); ------------------ | | 142| 38.5k| ((GData*) ((gsize) g_atomic_pointer_get (datalist) & ~(gsize) G_DATALIST_FLAGS_MASK_INTERNAL)) | | ------------------ | | | | 113| 38.5k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 38.5k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 38.5k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 38.5k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 38.5k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 38.5k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 38.5k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 38.5k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 38.5k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 38.5k| gapg_temp_newval; \ | | | | 119| 38.5k| })) | | ------------------ | | ((GData*) ((gsize) g_atomic_pointer_get (datalist) & ~(gsize) G_DATALIST_FLAGS_MASK_INTERNAL)) | | ------------------ | | | | 138| 38.5k|#define G_DATALIST_FLAGS_MASK_INTERNAL 0x7 | | ------------------ ------------------ 357| | 358| 38.5k| if (new_data == NULL) /* remove */ ------------------ | Branch (358:7): [True: 34.6k, False: 3.85k] ------------------ 359| 34.6k| { 360| 34.6k| if (d) ------------------ | Branch (360:11): [True: 3.85k, False: 30.8k] ------------------ 361| 3.85k| { 362| 3.85k| data = d->data; 363| 3.85k| data_last = data + d->len - 1; 364| 3.85k| while (data <= data_last) ------------------ | Branch (364:11): [True: 3.85k, False: 0] ------------------ 365| 3.85k| { 366| 3.85k| if (data->key == key_id) ------------------ | Branch (366:12): [True: 3.85k, False: 0] ------------------ 367| 3.85k| { 368| 3.85k| old = *data; 369| 3.85k| if (data != data_last) ------------------ | Branch (369:9): [True: 0, False: 3.85k] ------------------ 370| 0| *data = *data_last; 371| 3.85k| d->len--; 372| | 373| | /* We don't bother to shrink, but if all data are now gone 374| | * we at least free the memory 375| | */ 376| 3.85k| if (d->len == 0) ------------------ | Branch (376:9): [True: 3.85k, False: 0] ------------------ 377| 3.85k| { 378| 3.85k| G_DATALIST_SET_POINTER (datalist, NULL); ------------------ | | 144| 3.85k|#define G_DATALIST_SET_POINTER(datalist, pointer) G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 145| 3.85k| gpointer _oldv, _newv; \ | | 146| 3.85k| do { \ | | 147| 3.85k| _oldv = g_atomic_pointer_get (datalist); \ | | ------------------ | | | | 113| 3.85k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 3.85k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 3.85k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 3.85k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 3.85k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 3.85k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 3.85k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 3.85k| gapg_temp_newval; \ | | | | 119| 3.85k| })) | | ------------------ | | 148| 3.85k| _newv = (gpointer) (((gsize) _oldv & G_DATALIST_FLAGS_MASK_INTERNAL) | (gsize) pointer); \ | | ------------------ | | | | 138| 3.85k|#define G_DATALIST_FLAGS_MASK_INTERNAL 0x7 | | ------------------ | | 149| 3.85k| } while (!g_atomic_pointer_compare_and_exchange ((void**) datalist, _oldv, _newv)); \ | | ------------------ | | | | 210| 3.85k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 211| 3.85k| G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 212| 3.85k| gpointer gapcae_oldval = (gpointer)(oldval); \ | | | | 213| 3.85k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 214| 3.85k| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | | | ------------------ | | | | | Branch (214:13): [Folded, False: 3.85k] | | | | ------------------ | | | | 215| 3.85k| __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 814| 3.85k|#define FALSE (0) | | | | ------------------ | | | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 818| 3.85k|#define TRUE (!FALSE) | | | | | | ------------------ | | | | | | | | 814| 3.85k|#define FALSE (0) | | | | | | ------------------ | | | | ------------------ | | | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 814| 0|#define FALSE (0) | | | | ------------------ | | | | | Branch (215:5): [True: 3.85k, False: 0] | | | | ------------------ | | | | 216| 3.85k| })) | | ------------------ | | | Branch (149:12): [True: 0, False: 3.85k] | | ------------------ | | 150| 3.85k|} G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 379| 3.85k| g_free (d); 380| | /* datalist may be situated in dataset, so must not be 381| | * unlocked after we free it 382| | */ 383| 3.85k| g_datalist_unlock (datalist); 384| | 385| | /* the dataset destruction *must* be done 386| | * prior to invocation of the data destroy function 387| | */ 388| 3.85k| if (dataset) ------------------ | Branch (388:13): [True: 0, False: 3.85k] ------------------ 389| 0| g_dataset_destroy_internal (dataset); 390| 3.85k| } 391| 0| else 392| 0| { 393| 0| g_datalist_unlock (datalist); 394| 0| } 395| | 396| | /* We found and removed an old value 397| | * the GData struct *must* already be unlinked 398| | * when invoking the destroy function. 399| | * we use (new_data==NULL && new_destroy_func!=NULL) as 400| | * a special hint combination to "steal" 401| | * data without destroy notification 402| | */ 403| 3.85k| if (old.destroy && !new_destroy_func) ------------------ | Branch (403:9): [True: 3.85k, False: 0] | Branch (403:24): [True: 3.85k, False: 0] ------------------ 404| 3.85k| { 405| 3.85k| if (dataset) ------------------ | Branch (405:13): [True: 0, False: 3.85k] ------------------ 406| 0| G_UNLOCK (g_dataset_global); ------------------ | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 407| 3.85k| old.destroy (old.data); 408| 3.85k| if (dataset) ------------------ | Branch (408:13): [True: 0, False: 3.85k] ------------------ 409| 0| G_LOCK (g_dataset_global); ------------------ | | 135| 0|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 410| 3.85k| old.data = NULL; 411| 3.85k| } 412| | 413| 3.85k| return old.data; 414| 3.85k| } 415| 0| data++; 416| 0| } 417| 3.85k| } 418| 34.6k| } 419| 3.85k| else 420| 3.85k| { 421| 3.85k| old.data = NULL; 422| 3.85k| if (d) ------------------ | Branch (422:11): [True: 0, False: 3.85k] ------------------ 423| 0| { 424| 0| data = d->data; 425| 0| data_end = data + d->len; 426| 0| while (data < data_end) ------------------ | Branch (426:11): [True: 0, False: 0] ------------------ 427| 0| { 428| 0| if (data->key == key_id) ------------------ | Branch (428:12): [True: 0, False: 0] ------------------ 429| 0| { 430| 0| if (!data->destroy) ------------------ | Branch (430:9): [True: 0, False: 0] ------------------ 431| 0| { 432| 0| data->data = new_data; 433| 0| data->destroy = new_destroy_func; 434| 0| g_datalist_unlock (datalist); 435| 0| } 436| 0| else 437| 0| { 438| 0| old = *data; 439| 0| data->data = new_data; 440| 0| data->destroy = new_destroy_func; 441| | 442| 0| g_datalist_unlock (datalist); 443| | 444| | /* We found and replaced an old value 445| | * the GData struct *must* already be unlinked 446| | * when invoking the destroy function. 447| | */ 448| 0| if (dataset) ------------------ | Branch (448:13): [True: 0, False: 0] ------------------ 449| 0| G_UNLOCK (g_dataset_global); ------------------ | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 450| 0| old.destroy (old.data); 451| 0| if (dataset) ------------------ | Branch (451:13): [True: 0, False: 0] ------------------ 452| 0| G_LOCK (g_dataset_global); ------------------ | | 135| 0|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 453| 0| } 454| 0| return NULL; 455| 0| } 456| 0| data++; 457| 0| } 458| 0| } 459| | 460| | /* The key was not found, insert it */ 461| 3.85k| old_d = d; 462| 3.85k| if (d == NULL) ------------------ | Branch (462:11): [True: 3.85k, False: 0] ------------------ 463| 3.85k| { 464| 3.85k| d = g_malloc (sizeof (GData)); 465| 3.85k| d->len = 0; 466| 3.85k| d->alloc = 1; 467| 3.85k| } 468| 0| else if (d->len == d->alloc) ------------------ | Branch (468:16): [True: 0, False: 0] ------------------ 469| 0| { 470| 0| d->alloc = d->alloc * 2; 471| 0| d = g_realloc (d, sizeof (GData) + (d->alloc - 1) * sizeof (GDataElt)); 472| 0| } 473| 3.85k| if (old_d != d) ------------------ | Branch (473:11): [True: 3.85k, False: 0] ------------------ 474| 3.85k| G_DATALIST_SET_POINTER (datalist, d); ------------------ | | 144| 3.85k|#define G_DATALIST_SET_POINTER(datalist, pointer) G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 145| 3.85k| gpointer _oldv, _newv; \ | | 146| 3.85k| do { \ | | 147| 3.85k| _oldv = g_atomic_pointer_get (datalist); \ | | ------------------ | | | | 113| 3.85k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 3.85k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 3.85k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 3.85k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 3.85k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 3.85k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 3.85k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 3.85k| gapg_temp_newval; \ | | | | 119| 3.85k| })) | | ------------------ | | 148| 3.85k| _newv = (gpointer) (((gsize) _oldv & G_DATALIST_FLAGS_MASK_INTERNAL) | (gsize) pointer); \ | | ------------------ | | | | 138| 3.85k|#define G_DATALIST_FLAGS_MASK_INTERNAL 0x7 | | ------------------ | | 149| 3.85k| } while (!g_atomic_pointer_compare_and_exchange ((void**) datalist, _oldv, _newv)); \ | | ------------------ | | | | 210| 3.85k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 211| 3.85k| G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 212| 3.85k| gpointer gapcae_oldval = (gpointer)(oldval); \ | | | | 213| 3.85k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 214| 3.85k| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | | | ------------------ | | | | | Branch (214:13): [Folded, False: 3.85k] | | | | ------------------ | | | | 215| 3.85k| __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 814| 3.85k|#define FALSE (0) | | | | ------------------ | | | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 818| 3.85k|#define TRUE (!FALSE) | | | | | | ------------------ | | | | | | | | 814| 3.85k|#define FALSE (0) | | | | | | ------------------ | | | | ------------------ | | | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | ------------------ | | | | | | 814| 0|#define FALSE (0) | | | | ------------------ | | | | | Branch (215:5): [True: 3.85k, False: 0] | | | | ------------------ | | | | 216| 3.85k| })) | | ------------------ | | | Branch (149:12): [True: 0, False: 3.85k] | | ------------------ | | 150| 3.85k|} G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 475| | 476| 3.85k| d->data[d->len].key = key_id; 477| 3.85k| d->data[d->len].data = new_data; 478| 3.85k| d->data[d->len].destroy = new_destroy_func; 479| 3.85k| d->len++; 480| 3.85k| } 481| | 482| 34.6k| g_datalist_unlock (datalist); 483| | 484| 34.6k| return NULL; 485| | 486| 38.5k|} g_getenv: 252| 259k|{ 253| 259k| g_return_val_if_fail (variable != NULL, NULL); ------------------ | | 643| 259k| G_STMT_START { \ | | ------------------ | | | | 874| 259k|#define G_STMT_START do | | ------------------ | | 644| 259k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 259k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 259k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 259k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 259k| int _g_boolean_var_; \ | | | | | | 1018| 259k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 259k, False: 0] | | | | | | ------------------ | | | | | | 1019| 259k| _g_boolean_var_ = 1; \ | | | | | | 1020| 259k| else \ | | | | | | 1021| 259k| _g_boolean_var_ = 0; \ | | | | | | 1022| 259k| _g_boolean_var_; \ | | | | | | 1023| 259k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 259k, False: 0] | | | | ------------------ | | ------------------ | | 645| 259k| { } \ | | 646| 259k| else \ | | 647| 259k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 259k| } G_STMT_END | | ------------------ | | | | 882| 259k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 259k] | | | | ------------------ | | ------------------ ------------------ 254| | 255| 259k| return getenv (variable); 256| 259k|} g_setenv: 293| 7.70k|{ 294| 7.70k| gint result; 295| |#ifndef HAVE_SETENV 296| | gchar *string; 297| |#endif 298| | 299| 7.70k| g_return_val_if_fail (variable != NULL, FALSE); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 300| 7.70k| g_return_val_if_fail (strchr (variable, '=') == NULL, FALSE); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 301| 7.70k| g_return_val_if_fail (value != NULL, FALSE); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 302| | 303| 7.70k|#ifndef G_DISABLE_CHECKS 304| | /* FIXME: This will be upgraded to a g_warning() in a future release of GLib. 305| | * See https://gitlab.gnome.org/GNOME/glib/issues/715 */ 306| 7.70k| if (g_thread_n_created () > 0) ------------------ | Branch (306:7): [True: 0, False: 7.70k] ------------------ 307| 0| g_debug ("setenv()/putenv() are not thread-safe and should not be used after threads are created"); ------------------ | | 351| 0|#define g_debug(...) g_log (G_LOG_DOMAIN, \ | | 352| 0| G_LOG_LEVEL_DEBUG, \ | | 353| 0| __VA_ARGS__) ------------------ 308| 7.70k|#endif 309| | 310| 7.70k|#ifdef HAVE_SETENV 311| 7.70k| result = setenv (variable, value, overwrite); 312| |#else 313| | if (!overwrite && getenv (variable) != NULL) 314| | return TRUE; 315| | 316| | /* This results in a leak when you overwrite existing 317| | * settings. It would be fairly easy to fix this by keeping 318| | * our own parallel array or hash table. 319| | */ 320| | string = g_strconcat (variable, "=", value, NULL); 321| | result = putenv (string); 322| |#endif 323| 7.70k| return result == 0; 324| 7.70k|} g_error_init: 516| 2|{ 517| 2| error_domain_ht = g_hash_table_new (NULL, NULL); 518| 2|} g_set_error: 946| 1.27k|{ 947| 1.27k| GError *new; 948| | 949| 1.27k| va_list args; 950| | 951| 1.27k| if (err == NULL) ------------------ | Branch (951:7): [True: 1.27k, False: 0] ------------------ 952| 1.27k| return; 953| | 954| 1.27k| va_start (args, format); 955| 0| new = g_error_new_valist (domain, code, format, args); 956| 0| va_end (args); 957| | 958| 0| if (*err == NULL) ------------------ | Branch (958:7): [True: 0, False: 0] ------------------ 959| 0| *err = new; 960| 0| else 961| 0| { 962| 0| g_warning (ERROR_OVERWRITTEN_WARNING, new->message); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 963| 0| g_error_free (new); 964| 0| } 965| 0|} g_set_error_literal: 987| 1.96k|{ 988| 1.96k| if (err == NULL) ------------------ | Branch (988:7): [True: 1.96k, False: 0] ------------------ 989| 1.96k| return; 990| | 991| 0| if (*err == NULL) ------------------ | Branch (991:7): [True: 0, False: 0] ------------------ 992| 0| *err = g_error_new_literal (domain, code, message); 993| 0| else 994| 0| g_warning (ERROR_OVERWRITTEN_WARNING, message); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 995| 0|} g_prefix_error: 1086| 1.35k|{ 1087| 1.35k| if (err && *err) ------------------ | Branch (1087:7): [True: 0, False: 1.35k] | Branch (1087:14): [True: 0, False: 0] ------------------ 1088| 0| { 1089| 0| va_list ap; 1090| | 1091| 0| va_start (ap, format); 1092| 0| g_error_add_prefix (&(*err)->message, format, ap); 1093| | va_end (ap); 1094| 0| } 1095| 1.35k|} glib_gettext: 128| 38|{ 129| 38| ensure_gettext_initialized (); 130| | 131| 38| return g_dgettext (GETTEXT_PACKAGE, str); ------------------ | | 22| 38|#define GETTEXT_PACKAGE "glib20" ------------------ 132| 38|} g_dgettext: 398| 38|{ 399| 38| if (domain && G_UNLIKELY (!_g_dgettext_should_translate ())) ------------------ | | 1025| 38|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 38| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 38| int _g_boolean_var_; \ | | | | 1018| 38| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 38] | | | | ------------------ | | | | 1019| 38| _g_boolean_var_ = 1; \ | | | | 1020| 38| else \ | | | | 1021| 38| _g_boolean_var_ = 0; \ | | | | 1022| 38| _g_boolean_var_; \ | | | | 1023| 38|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 38] | | ------------------ ------------------ | Branch (399:7): [True: 38, False: 0] ------------------ 400| 0| return msgid; 401| | 402| 38| return dgettext (domain, msgid); 403| 38|} ggettext.c:ensure_gettext_initialized: 97| 38|{ 98| 38| static gsize initialised; 99| | 100| 38| if (g_once_init_enter (&initialised)) ------------------ | | 257| 38| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | | Branch (257:3): [True: 1, False: 37] | | ------------------ | | 258| 38| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 38|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 259| 38| (void) (0 ? (gpointer) *(location) : NULL); \ | | ------------------ | | | Branch (259:13): [Folded, False: 38] | | ------------------ | | 260| 38| (!g_atomic_pointer_get (location) && \ | | ------------------ | | | | 113| 76| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 76| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 38|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 76| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 38|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 76| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 38|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 76| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 76| gapg_temp_newval; \ | | | | 119| 76| })) | | ------------------ | | | Branch (260:6): [True: 1, False: 37] | | ------------------ | | 261| 38| g_once_init_enter (location)); \ | | ------------------ | | | Branch (261:6): [True: 1, False: 0] | | ------------------ | | 262| 38| })) ------------------ 101| 1| { 102| |#ifdef G_OS_WIN32 103| | gchar *tmp = _glib_get_locale_dir (); 104| | bindtextdomain (GETTEXT_PACKAGE, tmp); 105| | g_free (tmp); 106| |#else 107| 1| bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR); ------------------ | | 22| 1|#define GETTEXT_PACKAGE "glib20" ------------------ bindtextdomain (GETTEXT_PACKAGE, GLIB_LOCALE_DIR); ------------------ | | 28| 1|#define GLIB_LOCALE_DIR "/work/share/locale" ------------------ 108| 1|#endif 109| 1|# ifdef HAVE_BIND_TEXTDOMAIN_CODESET 110| 1| bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); ------------------ | | 22| 1|#define GETTEXT_PACKAGE "glib20" ------------------ 111| 1|# endif 112| 1| g_once_init_leave (&initialised, TRUE); ------------------ | | 264| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 265| 1| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 266| 1| 0 ? (void) (*(location) = (result)) : (void) 0; \ | | ------------------ | | | Branch (266:5): [Folded, False: 1] | | ------------------ | | 267| 1| g_once_init_leave ((location), (gsize) (result)); \ | | 268| 1| })) ------------------ 113| 1| } 114| 38|} ggettext.c:_g_dgettext_should_translate: 304| 38|{ 305| 38| static gsize translate = 0; 306| 38| enum { 307| 38| SHOULD_TRANSLATE = 1, 308| 38| SHOULD_NOT_TRANSLATE = 2 309| 38| }; 310| | 311| 38| if (G_UNLIKELY (g_once_init_enter (&translate))) ------------------ | | 1025| 38|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 38| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 38| int _g_boolean_var_; \ | | | | 1018| 153| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [Folded, False: 38] | | | | | Branch (1018:8): [True: 1, False: 37] | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | Branch (1018:8): [True: 1, False: 37] | | | | ------------------ | | | | 1019| 38| _g_boolean_var_ = 1; \ | | | | 1020| 38| else \ | | | | 1021| 38| _g_boolean_var_ = 0; \ | | | | 1022| 38| _g_boolean_var_; \ | | | | 1023| 38|}) | | ------------------ | | | Branch (1025:26): [True: 1, False: 37] | | ------------------ ------------------ 312| 1| { 313| 1| gboolean should_translate = TRUE; ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 314| | 315| 1| const char *default_domain = textdomain (NULL); 316| 1| const char *translator_comment = gettext (""); 317| 1|#ifndef G_OS_WIN32 318| 1| const char *translate_locale = setlocale (LC_MESSAGES, NULL); 319| |#else 320| | const char *translate_locale = g_win32_getlocale (); 321| |#endif 322| | /* We should NOT translate only if all the following hold: 323| | * - user has called textdomain() and set textdomain to non-default 324| | * - default domain has no translations 325| | * - locale does not start with "en_" and is not "C" 326| | * 327| | * Rationale: 328| | * - If text domain is still the default domain, maybe user calls 329| | * it later. Continue with old behavior of translating. 330| | * - If locale starts with "en_", we can continue using the 331| | * translations even if the app doesn't have translations for 332| | * this locale. That is, en_UK and en_CA for example. 333| | * - If locale is "C", maybe user calls setlocale(LC_ALL,"") later. 334| | * Continue with old behavior of translating. 335| | */ 336| 1| if (!default_domain || !translator_comment || !translate_locale || ------------------ | Branch (336:11): [True: 0, False: 1] | Branch (336:30): [True: 0, False: 1] | Branch (336:53): [True: 0, False: 1] ------------------ 337| 1| (0 != strcmp (default_domain, "messages") && ------------------ | Branch (337:12): [True: 0, False: 1] ------------------ 338| 0| '\0' == *translator_comment && ------------------ | Branch (338:11): [True: 0, False: 0] ------------------ 339| 0| 0 != strncmp (translate_locale, "en_", 3) && ------------------ | Branch (339:11): [True: 0, False: 0] ------------------ 340| 0| 0 != strcmp (translate_locale, "C"))) ------------------ | Branch (340:11): [True: 0, False: 0] ------------------ 341| 0| should_translate = FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 342| | 343| 1| g_once_init_leave (&translate, ------------------ | | 264| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 265| 1| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 266| 1| 0 ? (void) (*(location) = (result)) : (void) 0; \ | | ------------------ | | | Branch (266:5): [Folded, False: 1] | | | Branch (266:32): [True: 0, False: 0] | | ------------------ | | 267| 2| g_once_init_leave ((location), (gsize) (result)); \ | | ------------------ | | | Branch (267:45): [True: 1, False: 0] | | ------------------ | | 268| 1| })) ------------------ 344| 1| should_translate ? 345| 1| SHOULD_TRANSLATE : 346| 1| SHOULD_NOT_TRANSLATE); 347| 1| } 348| | 349| 38| return translate == SHOULD_TRANSLATE; 350| 38|} g_hash_table_new: 1033| 12|{ 1034| 12| return g_hash_table_new_full (hash_func, key_equal_func, NULL, NULL); 1035| 12|} g_hash_table_new_full: 1068| 13|{ 1069| 13| GHashTable *hash_table; 1070| | 1071| 13| hash_table = g_slice_new (GHashTable); ------------------ | | 46| 13|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) ------------------ 1072| 13| g_atomic_ref_count_init (&hash_table->ref_count); 1073| 13| hash_table->nnodes = 0; 1074| 13| hash_table->noccupied = 0; 1075| 13| hash_table->hash_func = hash_func ? hash_func : g_direct_hash; ------------------ | Branch (1075:36): [True: 11, False: 2] ------------------ 1076| 13| hash_table->key_equal_func = key_equal_func; 1077| 13|#ifndef G_DISABLE_ASSERT 1078| 13| hash_table->version = 0; 1079| 13|#endif 1080| 13| hash_table->key_destroy_func = key_destroy_func; 1081| 13| hash_table->value_destroy_func = value_destroy_func; 1082| | 1083| 13| g_hash_table_setup_storage (hash_table); 1084| | 1085| 13| return hash_table; 1086| 13|} g_hash_table_lookup: 1505| 15.8k|{ 1506| 15.8k| guint node_index; 1507| 15.8k| guint node_hash; 1508| | 1509| 15.8k| g_return_val_if_fail (hash_table != NULL, NULL); ------------------ | | 643| 15.8k| G_STMT_START { \ | | ------------------ | | | | 874| 15.8k|#define G_STMT_START do | | ------------------ | | 644| 15.8k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 15.8k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 15.8k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 15.8k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 15.8k| int _g_boolean_var_; \ | | | | | | 1018| 15.8k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 15.8k, False: 0] | | | | | | ------------------ | | | | | | 1019| 15.8k| _g_boolean_var_ = 1; \ | | | | | | 1020| 15.8k| else \ | | | | | | 1021| 15.8k| _g_boolean_var_ = 0; \ | | | | | | 1022| 15.8k| _g_boolean_var_; \ | | | | | | 1023| 15.8k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 15.8k, False: 0] | | | | ------------------ | | ------------------ | | 645| 15.8k| { } \ | | 646| 15.8k| else \ | | 647| 15.8k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 15.8k| } G_STMT_END | | ------------------ | | | | 882| 15.8k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 15.8k] | | | | ------------------ | | ------------------ ------------------ 1510| | 1511| 15.8k| node_index = g_hash_table_lookup_node (hash_table, key, &node_hash); 1512| | 1513| 15.8k| return HASH_IS_REAL (hash_table->hashes[node_index]) ------------------ | | 242| 15.8k|#define HASH_IS_REAL(h_) ((h_) >= 2) | | ------------------ | | | Branch (242:26): [True: 105, False: 15.7k] | | ------------------ ------------------ 1514| 15.8k| ? g_hash_table_fetch_key_or_value (hash_table->values, node_index, hash_table->have_big_values) 1515| | : NULL; 1516| 15.8k|} g_hash_table_insert: 1628| 263|{ 1629| 263| return g_hash_table_insert_internal (hash_table, key, value, FALSE); ------------------ | | 814| 263|#define FALSE (0) ------------------ 1630| 263|} g_hash_table_add: 1688| 1|{ 1689| 1| return g_hash_table_insert_internal (hash_table, key, key, TRUE); ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 1690| 1|} g_hash_table_foreach: 2045| 3|{ 2046| 3| gsize i; 2047| 3|#ifndef G_DISABLE_ASSERT 2048| 3| gint version; 2049| 3|#endif 2050| | 2051| 3| g_return_if_fail (hash_table != NULL); ------------------ | | 630| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 631| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 632| 3| { } \ | | 633| 3| else \ | | 634| 3| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2052| 3| g_return_if_fail (func != NULL); ------------------ | | 630| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 631| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 632| 3| { } \ | | 633| 3| else \ | | 634| 3| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2053| | 2054| 3|#ifndef G_DISABLE_ASSERT 2055| 3| version = hash_table->version; 2056| 3|#endif 2057| | 2058| 27| for (i = 0; i < hash_table->size; i++) ------------------ | Branch (2058:15): [True: 24, False: 3] ------------------ 2059| 24| { 2060| 24| guint node_hash = hash_table->hashes[i]; 2061| 24| gpointer node_key = g_hash_table_fetch_key_or_value (hash_table->keys, i, hash_table->have_big_keys); 2062| 24| gpointer node_value = g_hash_table_fetch_key_or_value (hash_table->values, i, hash_table->have_big_values); 2063| | 2064| 24| if (HASH_IS_REAL (node_hash)) ------------------ | | 242| 24|#define HASH_IS_REAL(h_) ((h_) >= 2) | | ------------------ | | | Branch (242:26): [True: 3, False: 21] | | ------------------ ------------------ 2065| 3| (* func) (node_key, node_value, user_data); 2066| | 2067| 24|#ifndef G_DISABLE_ASSERT 2068| 24| g_return_if_fail (version == hash_table->version); ------------------ | | 630| 24| G_STMT_START { \ | | ------------------ | | | | 874| 24|#define G_STMT_START do | | ------------------ | | 631| 24| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 24|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 24| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 24|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 24| int _g_boolean_var_; \ | | | | | | 1018| 24| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 24, False: 0] | | | | | | ------------------ | | | | | | 1019| 24| _g_boolean_var_ = 1; \ | | | | | | 1020| 24| else \ | | | | | | 1021| 24| _g_boolean_var_ = 0; \ | | | | | | 1022| 24| _g_boolean_var_; \ | | | | | | 1023| 24|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 24, False: 0] | | | | ------------------ | | ------------------ | | 632| 24| { } \ | | 633| 24| else \ | | 634| 24| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 24| } G_STMT_END | | ------------------ | | | | 882| 24|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 24] | | | | ------------------ | | ------------------ ------------------ 2069| 24|#endif 2070| 24| } 2071| 3|} g_str_equal: 2299| 106|{ 2300| 106| const gchar *string1 = v1; 2301| 106| const gchar *string2 = v2; 2302| | 2303| 106| return strcmp (string1, string2) == 0; 2304| 106|} g_str_hash: 2329| 633|{ 2330| 633| const signed char *p; 2331| 633| guint32 h = 5381; 2332| | 2333| 8.15k| for (p = v; *p != '\0'; p++) ------------------ | Branch (2333:15): [True: 7.52k, False: 633] ------------------ 2334| 7.52k| h = (h << 5) + h + *p; 2335| | 2336| 633| return h; 2337| 633|} g_direct_hash: 2355| 15.4k|{ 2356| 15.4k| return GPOINTER_TO_UINT (v); ------------------ | | 99| 15.4k|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 2357| 15.4k|} g_int_hash: 2421| 44|{ 2422| 44| return *(const gint*) v; 2423| 44|} ghash.c:g_hash_table_setup_storage: 567| 13|{ 568| 13| gboolean small = FALSE; ------------------ | | 814| 13|#define FALSE (0) ------------------ 569| | 570| | /* We want to use small arrays only if: 571| | * - we are running on a system where that makes sense (64 bit); and 572| | * - we are not running under valgrind. 573| | */ 574| | 575| 13|#ifdef USE_SMALL_ARRAYS 576| 13| small = TRUE; ------------------ | | 818| 13|#define TRUE (!FALSE) | | ------------------ | | | | 814| 13|#define FALSE (0) | | ------------------ ------------------ 577| | 578| 13|# ifdef ENABLE_VALGRIND 579| 13| if (RUNNING_ON_VALGRIND) ------------------ | | 6215| 13| (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ | | ------------------ | | | | 413| 13| __extension__ \ | | | | 414| 13| ({ volatile unsigned long int _zzq_args[6]; \ | | | | 415| 13| volatile unsigned long int _zzq_result; \ | | | | 416| 13| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | 417| 13| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | 418| 13| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | 419| 13| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | 420| 13| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | 421| 13| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | 422| 13| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | 423| 13| /* %RDX = client_request ( %RAX ) */ \ | | | | 424| 13| "xchgq %%rbx,%%rbx" \ | | | | 425| 13| : "=d" (_zzq_result) \ | | | | 426| 13| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | 427| 13| : "cc", "memory" \ | | | | 428| 13| ); \ | | | | 429| 13| _zzq_result; \ | | | | 430| 13| }) | | ------------------ | | | Branch (6215:5): [True: 0, False: 13] | | ------------------ | | 6216| 13| VG_USERREQ__RUNNING_ON_VALGRIND, \ | | 6217| 13| 0, 0, 0, 0, 0) \ ------------------ 580| 0| small = FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 581| 13|# endif 582| 13|#endif 583| | 584| 13| g_hash_table_set_shift (hash_table, HASH_TABLE_MIN_SHIFT); ------------------ | | 236| 13|#define HASH_TABLE_MIN_SHIFT 3 /* 1 << 3 == 8 buckets */ ------------------ 585| | 586| 13| hash_table->have_big_keys = !small; 587| 13| hash_table->have_big_values = !small; 588| | 589| 13| hash_table->keys = g_hash_table_realloc_key_or_value_array (NULL, hash_table->size, hash_table->have_big_keys); 590| 13| hash_table->values = hash_table->keys; 591| | hash_table->hashes = g_new0 (guint, hash_table->size); ------------------ | | 307| 13|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 13| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 13|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 13| gsize __n = (gsize) (n_structs); \ | | | | 237| 13| gsize __s = sizeof (struct_type); \ | | | | 238| 13| gpointer __p; \ | | | | 239| 13| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 13] | | | | ------------------ | | | | 240| 13| __p = g_##func (__n); \ | | | | 241| 13| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 13] | | | | ------------------ | | | | 242| 13| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 13| __p = g_##func (__n * __s); \ | | | | 244| 13| else \ | | | | 245| 13| __p = g_##func##_n (__n, __s); \ | | | | 246| 13| __p; \ | | | | 247| 13| })) | | ------------------ ------------------ 592| 13|} ghash.c:g_hash_table_set_shift: 342| 30|{ 343| 30| hash_table->size = 1 << shift; 344| 30| hash_table->mod = prime_mod [shift]; 345| | 346| | /* hash_table->size is always a power of two, so we can calculate the mask 347| | * by simply subtracting 1 from it. The leading assertion ensures that 348| | * we're really dealing with a power of two. */ 349| | 350| 30| g_assert ((hash_table->size & (hash_table->size - 1)) == 0); ------------------ | | 231| 30|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 30|#define G_STMT_START do | | ------------------ | | 232| 30| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 30|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 30| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 30|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 30| int _g_boolean_var_; \ | | | | | | 1018| 30| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 30, False: 0] | | | | | | ------------------ | | | | | | 1019| 30| _g_boolean_var_ = 1; \ | | | | | | 1020| 30| else \ | | | | | | 1021| 30| _g_boolean_var_ = 0; \ | | | | | | 1022| 30| _g_boolean_var_; \ | | | | | | 1023| 30|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 30, False: 0] | | | | ------------------ | | ------------------ | | 233| 30| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 30| } G_STMT_END | | ------------------ | | | | 882| 30|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 30] | | | | ------------------ | | ------------------ ------------------ 351| 30| hash_table->mask = hash_table->size - 1; 352| 30|} ghash.c:g_hash_table_realloc_key_or_value_array: 378| 45|{ 379| 45|#ifdef USE_SMALL_ARRAYS 380| 45| return g_realloc (a, size * (is_big ? BIG_ENTRY_SIZE : SMALL_ENTRY_SIZE)); ------------------ | | 249| 25|#define BIG_ENTRY_SIZE (SIZEOF_VOID_P) | | ------------------ | | | | 392| 25|#define SIZEOF_VOID_P 8 | | ------------------ ------------------ return g_realloc (a, size * (is_big ? BIG_ENTRY_SIZE : SMALL_ENTRY_SIZE)); ------------------ | | 250| 20|#define SMALL_ENTRY_SIZE (SIZEOF_INT) | | ------------------ | | | | 380| 20|#define SIZEOF_INT 4 | | ------------------ ------------------ | Branch (380:32): [True: 25, False: 20] ------------------ 381| |#else 382| | return g_renew (gpointer, a, size); 383| |#endif 384| 45|} ghash.c:g_hash_table_fetch_key_or_value: 388| 258|{ 389| |#ifndef USE_SMALL_ARRAYS 390| | is_big = TRUE; 391| |#endif 392| 258| return is_big ? *(((gpointer *) a) + index) : GUINT_TO_POINTER (*(((guint *) a) + index)); ------------------ | | 102| 105|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ | Branch (392:10): [True: 153, False: 105] ------------------ 393| 258|} ghash.c:g_hash_table_insert_node: 1272| 264|{ 1273| 264| gboolean already_exists; 1274| 264| guint old_hash; 1275| 264| gpointer key_to_free = NULL; 1276| 264| gpointer key_to_keep = NULL; 1277| 264| gpointer value_to_free = NULL; 1278| | 1279| 264| old_hash = hash_table->hashes[node_index]; 1280| 264| already_exists = HASH_IS_REAL (old_hash); ------------------ | | 242| 264|#define HASH_IS_REAL(h_) ((h_) >= 2) ------------------ 1281| | 1282| | /* Proceed in three steps. First, deal with the key because it is the 1283| | * most complicated. Then consider if we need to split the table in 1284| | * two (because writing the value will result in the set invariant 1285| | * becoming broken). Then deal with the value. 1286| | * 1287| | * There are three cases for the key: 1288| | * 1289| | * - entry already exists in table, reusing key: 1290| | * free the just-passed-in new_key and use the existing value 1291| | * 1292| | * - entry already exists in table, not reusing key: 1293| | * free the entry in the table, use the new key 1294| | * 1295| | * - entry not already in table: 1296| | * use the new key, free nothing 1297| | * 1298| | * We update the hash at the same time... 1299| | */ 1300| 264| if (already_exists) ------------------ | Branch (1300:7): [True: 0, False: 264] ------------------ 1301| 0| { 1302| | /* Note: we must record the old value before writing the new key 1303| | * because we might change the value in the event that the two 1304| | * arrays are shared. 1305| | */ 1306| 0| value_to_free = g_hash_table_fetch_key_or_value (hash_table->values, node_index, hash_table->have_big_values); 1307| | 1308| 0| if (keep_new_key) ------------------ | Branch (1308:11): [True: 0, False: 0] ------------------ 1309| 0| { 1310| 0| key_to_free = g_hash_table_fetch_key_or_value (hash_table->keys, node_index, hash_table->have_big_keys); 1311| 0| key_to_keep = new_key; 1312| 0| } 1313| 0| else 1314| 0| { 1315| 0| key_to_free = new_key; 1316| 0| key_to_keep = g_hash_table_fetch_key_or_value (hash_table->keys, node_index, hash_table->have_big_keys); 1317| 0| } 1318| 0| } 1319| 264| else 1320| 264| { 1321| 264| hash_table->hashes[node_index] = key_hash; 1322| 264| key_to_keep = new_key; 1323| 264| } 1324| | 1325| | /* Resize key/value arrays and split table as necessary */ 1326| 264| g_hash_table_ensure_keyval_fits (hash_table, key_to_keep, new_value); 1327| 264| g_hash_table_assign_key_or_value (hash_table->keys, node_index, hash_table->have_big_keys, key_to_keep); 1328| | 1329| | /* Step 3: Actually do the write */ 1330| 264| g_hash_table_assign_key_or_value (hash_table->values, node_index, hash_table->have_big_values, new_value); 1331| | 1332| | /* Now, the bookkeeping... */ 1333| 264| if (!already_exists) ------------------ | Branch (1333:7): [True: 264, False: 0] ------------------ 1334| 264| { 1335| 264| hash_table->nnodes++; 1336| | 1337| 264| if (HASH_IS_UNUSED (old_hash)) ------------------ | | 240| 264|#define HASH_IS_UNUSED(h_) ((h_) == UNUSED_HASH_VALUE) | | ------------------ | | | | 238| 264|#define UNUSED_HASH_VALUE 0 | | ------------------ | | | Branch (240:28): [True: 264, False: 0] | | ------------------ ------------------ 1338| 264| { 1339| | /* We replaced an empty node, and not a tombstone */ 1340| 264| hash_table->noccupied++; 1341| 264| g_hash_table_maybe_resize (hash_table); 1342| 264| } 1343| | 1344| 264|#ifndef G_DISABLE_ASSERT 1345| 264| hash_table->version++; 1346| 264|#endif 1347| 264| } 1348| | 1349| 264| if (already_exists) ------------------ | Branch (1349:7): [True: 0, False: 264] ------------------ 1350| 0| { 1351| 0| if (hash_table->key_destroy_func && !reusing_key) ------------------ | Branch (1351:11): [True: 0, False: 0] | Branch (1351:43): [True: 0, False: 0] ------------------ 1352| 0| (* hash_table->key_destroy_func) (key_to_free); 1353| 0| if (hash_table->value_destroy_func) ------------------ | Branch (1353:11): [True: 0, False: 0] ------------------ 1354| 0| (* hash_table->value_destroy_func) (value_to_free); 1355| 0| } 1356| | 1357| 264| return !already_exists; 1358| 264|} ghash.c:g_hash_table_ensure_keyval_fits: 954| 264|{ 955| 264| gboolean is_a_set = (hash_table->keys == hash_table->values); 956| | 957| 264|#ifdef USE_SMALL_ARRAYS 958| | 959| | /* Convert from set to map? */ 960| 264| if (is_a_set) ------------------ | Branch (960:7): [True: 28, False: 236] ------------------ 961| 28| { 962| 28| if (hash_table->have_big_keys) ------------------ | Branch (962:11): [True: 21, False: 7] ------------------ 963| 21| { 964| 21| if (key != value) ------------------ | Branch (964:15): [True: 0, False: 21] ------------------ 965| 0| hash_table->values = g_memdup2 (hash_table->keys, sizeof (gpointer) * hash_table->size); 966| | /* Keys and values are both big now, so no need for further checks */ 967| 21| return; 968| 21| } 969| 7| else 970| 7| { 971| 7| if (key != value) ------------------ | Branch (971:15): [True: 5, False: 2] ------------------ 972| 5| { 973| 5| hash_table->values = g_memdup2 (hash_table->keys, sizeof (guint) * hash_table->size); 974| 5| is_a_set = FALSE; ------------------ | | 814| 5|#define FALSE (0) ------------------ 975| 5| } 976| 7| } 977| 28| } 978| | 979| | /* Make keys big? */ 980| 243| if (!hash_table->have_big_keys) ------------------ | Branch (980:7): [True: 7, False: 236] ------------------ 981| 7| { 982| 7| hash_table->have_big_keys = g_hash_table_maybe_make_big_keys_or_values (&hash_table->keys, key, hash_table->size); 983| | 984| 7| if (is_a_set) ------------------ | Branch (984:11): [True: 2, False: 5] ------------------ 985| 2| { 986| 2| hash_table->values = hash_table->keys; 987| 2| hash_table->have_big_values = hash_table->have_big_keys; 988| 2| } 989| 7| } 990| | 991| | /* Make values big? */ 992| 243| if (!is_a_set && !hash_table->have_big_values) ------------------ | Branch (992:7): [True: 241, False: 2] | Branch (992:20): [True: 125, False: 116] ------------------ 993| 125| { 994| 125| hash_table->have_big_values = g_hash_table_maybe_make_big_keys_or_values (&hash_table->values, value, hash_table->size); 995| 125| } 996| | 997| |#else 998| | 999| | /* Just split if necessary */ 1000| | if (is_a_set && key != value) 1001| | hash_table->values = g_memdup2 (hash_table->keys, sizeof (gpointer) * hash_table->size); 1002| | 1003| |#endif 1004| 243|} ghash.c:g_hash_table_maybe_make_big_keys_or_values: 928| 132|{ 929| 132| if (entry_is_big (v)) ------------------ | Branch (929:7): [True: 10, False: 122] ------------------ 930| 10| { 931| 10| guint *a = (guint *) *a_p; 932| 10| gpointer *a_new; 933| 10| gint i; 934| | 935| 10| a_new = g_new (gpointer, ht_size); ------------------ | | 290| 10|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 10| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 10|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 10| gsize __n = (gsize) (n_structs); \ | | | | 237| 10| gsize __s = sizeof (struct_type); \ | | | | 238| 10| gpointer __p; \ | | | | 239| 10| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 10] | | | | ------------------ | | | | 240| 10| __p = g_##func (__n); \ | | | | 241| 10| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 10] | | | | ------------------ | | | | 242| 10| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 10| __p = g_##func (__n * __s); \ | | | | 244| 10| else \ | | | | 245| 10| __p = g_##func##_n (__n, __s); \ | | | | 246| 10| __p; \ | | | | 247| 10| })) | | ------------------ ------------------ 936| | 937| 90| for (i = 0; i < ht_size; i++) ------------------ | Branch (937:19): [True: 80, False: 10] ------------------ 938| 80| { 939| 80| a_new[i] = GUINT_TO_POINTER (a[i]); ------------------ | | 102| 80|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 940| 80| } 941| | 942| 10| g_free (a); 943| 10| *a_p = a_new; 944| 10| return TRUE; ------------------ | | 818| 10|#define TRUE (!FALSE) | | ------------------ | | | | 814| 10|#define FALSE (0) | | ------------------ ------------------ 945| 10| } 946| | 947| 122| return FALSE; ------------------ | | 814| 122|#define FALSE (0) ------------------ 948| 132|} ghash.c:entry_is_big: 922| 132|{ 923| 132| return (((guintptr) v) >> ((BIG_ENTRY_SIZE - SMALL_ENTRY_SIZE) * 8)) != 0; ------------------ | | 249| 132|#define BIG_ENTRY_SIZE (SIZEOF_VOID_P) | | ------------------ | | | | 392| 132|#define SIZEOF_VOID_P 8 | | ------------------ ------------------ return (((guintptr) v) >> ((BIG_ENTRY_SIZE - SMALL_ENTRY_SIZE) * 8)) != 0; ------------------ | | 250| 132|#define SMALL_ENTRY_SIZE (SIZEOF_INT) | | ------------------ | | | | 380| 132|#define SIZEOF_INT 4 | | ------------------ ------------------ 924| 132|} ghash.c:g_hash_table_lookup_node: 464| 16.0k|{ 465| 16.0k| guint node_index; 466| 16.0k| guint node_hash; 467| 16.0k| guint hash_value; 468| 16.0k| guint first_tombstone = 0; 469| 16.0k| gboolean have_tombstone = FALSE; ------------------ | | 814| 16.0k|#define FALSE (0) ------------------ 470| 16.0k| guint step = 0; 471| | 472| 16.0k| hash_value = hash_table->hash_func (key); 473| 16.0k| if (G_UNLIKELY (!HASH_IS_REAL (hash_value))) ------------------ | | 1025| 16.0k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 16.0k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 16.0k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 16.0k| int _g_boolean_var_; \ | | | | 1018| 16.0k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 16.0k] | | | | ------------------ | | | | 1019| 16.0k| _g_boolean_var_ = 1; \ | | | | 1020| 16.0k| else \ | | | | 1021| 16.0k| _g_boolean_var_ = 0; \ | | | | 1022| 16.0k| _g_boolean_var_; \ | | | | 1023| 16.0k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 16.0k] | | ------------------ ------------------ 474| 0| hash_value = 2; 475| | 476| 16.0k| *hash_return = hash_value; 477| | 478| 16.0k| node_index = g_hash_table_hash_to_index (hash_table, hash_value); 479| 16.0k| node_hash = hash_table->hashes[node_index]; 480| | 481| 17.7k| while (!HASH_IS_UNUSED (node_hash)) ------------------ | | 240| 17.7k|#define HASH_IS_UNUSED(h_) ((h_) == UNUSED_HASH_VALUE) | | ------------------ | | | | 238| 17.7k|#define UNUSED_HASH_VALUE 0 | | ------------------ ------------------ | Branch (481:10): [True: 1.80k, False: 15.9k] ------------------ 482| 1.80k| { 483| | /* We first check if our full hash values 484| | * are equal so we can avoid calling the full-blown 485| | * key equality function in most cases. 486| | */ 487| 1.80k| if (node_hash == hash_value) ------------------ | Branch (487:11): [True: 105, False: 1.70k] ------------------ 488| 105| { 489| 105| gpointer node_key = g_hash_table_fetch_key_or_value (hash_table->keys, node_index, hash_table->have_big_keys); 490| | 491| 105| if (hash_table->key_equal_func) ------------------ | Branch (491:15): [True: 105, False: 0] ------------------ 492| 105| { 493| 105| if (hash_table->key_equal_func (node_key, key)) ------------------ | Branch (493:19): [True: 105, False: 0] ------------------ 494| 105| return node_index; 495| 105| } 496| 0| else if (node_key == key) ------------------ | Branch (496:20): [True: 0, False: 0] ------------------ 497| 0| { 498| 0| return node_index; 499| 0| } 500| 105| } 501| 1.70k| else if (HASH_IS_TOMBSTONE (node_hash) && !have_tombstone) ------------------ | | 241| 3.40k|#define HASH_IS_TOMBSTONE(h_) ((h_) == TOMBSTONE_HASH_VALUE) | | ------------------ | | | | 239| 1.70k|#define TOMBSTONE_HASH_VALUE 1 | | ------------------ | | | Branch (241:31): [True: 0, False: 1.70k] | | ------------------ ------------------ | Branch (501:49): [True: 0, False: 0] ------------------ 502| 0| { 503| 0| first_tombstone = node_index; 504| 0| have_tombstone = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 505| 0| } 506| | 507| 1.70k| step++; 508| 1.70k| node_index += step; 509| 1.70k| node_index &= hash_table->mask; 510| 1.70k| node_hash = hash_table->hashes[node_index]; 511| 1.70k| } 512| | 513| 15.9k| if (have_tombstone) ------------------ | Branch (513:7): [True: 0, False: 15.9k] ------------------ 514| 0| return first_tombstone; 515| | 516| 15.9k| return node_index; 517| 15.9k|} ghash.c:g_hash_table_hash_to_index: 429| 16.4k|{ 430| | /* Multiply the hash by a small prime before applying the modulo. This 431| | * prevents the table from becoming densely packed, even with a poor hash 432| | * function. A densely packed table would have poor performance on 433| | * workloads with many failed lookups or a high degree of churn. */ 434| 16.4k| return (hash * 11) % hash_table->mod; 435| 16.4k|} ghash.c:g_hash_table_insert_internal: 1592| 264|{ 1593| 264| guint key_hash; 1594| 264| guint node_index; 1595| | 1596| 264| g_return_val_if_fail (hash_table != NULL, FALSE); ------------------ | | 643| 264| G_STMT_START { \ | | ------------------ | | | | 874| 264|#define G_STMT_START do | | ------------------ | | 644| 264| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 264|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 264| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 264|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 264| int _g_boolean_var_; \ | | | | | | 1018| 264| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 264, False: 0] | | | | | | ------------------ | | | | | | 1019| 264| _g_boolean_var_ = 1; \ | | | | | | 1020| 264| else \ | | | | | | 1021| 264| _g_boolean_var_ = 0; \ | | | | | | 1022| 264| _g_boolean_var_; \ | | | | | | 1023| 264|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 264, False: 0] | | | | ------------------ | | ------------------ | | 645| 264| { } \ | | 646| 264| else \ | | 647| 264| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 264| } G_STMT_END | | ------------------ | | | | 882| 264|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 264] | | | | ------------------ | | ------------------ ------------------ 1597| | 1598| 264| node_index = g_hash_table_lookup_node (hash_table, key, &key_hash); 1599| | 1600| 264| return g_hash_table_insert_node (hash_table, node_index, key_hash, key, value, keep_new_key, FALSE); ------------------ | | 814| 264|#define FALSE (0) ------------------ 1601| 264|} ghash.c:g_hash_table_assign_key_or_value: 397| 992|{ 398| |#ifndef USE_SMALL_ARRAYS 399| | is_big = TRUE; 400| |#endif 401| 992| if (is_big) ------------------ | Branch (401:7): [True: 745, False: 247] ------------------ 402| 745| *(((gpointer *) a) + index) = v; 403| 247| else 404| 247| *(((guint *) a) + index) = GPOINTER_TO_UINT (v); ------------------ | | 99| 247|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 405| 992|} ghash.c:g_hash_table_maybe_resize: 909| 264|{ 910| 264| gint noccupied = hash_table->noccupied; 911| 264| gint size = hash_table->size; 912| | 913| 264| if ((size > hash_table->nnodes * 4 && size > 1 << HASH_TABLE_MIN_SHIFT) || ------------------ | | 236| 7|#define HASH_TABLE_MIN_SHIFT 3 /* 1 << 3 == 8 buckets */ ------------------ | Branch (913:8): [True: 7, False: 257] | Branch (913:41): [True: 0, False: 7] ------------------ 914| 264| (size <= noccupied + (noccupied / 16))) ------------------ | Branch (914:7): [True: 17, False: 247] ------------------ 915| 17| g_hash_table_resize (hash_table); 916| 264|} ghash.c:g_hash_table_resize: 852| 17|{ 853| 17| guint32 *reallocated_buckets_bitmap; 854| 17| gsize old_size; 855| 17| gboolean is_a_set; 856| | 857| 17| old_size = hash_table->size; 858| 17| is_a_set = hash_table->keys == hash_table->values; 859| | 860| | /* The outer checks in g_hash_table_maybe_resize() will only consider 861| | * cleanup/resize when the load factor goes below .25 (1/4, ignoring 862| | * tombstones) or above .9375 (15/16, including tombstones). 863| | * 864| | * Once this happens, tombstones will always be cleaned out. If our 865| | * load sans tombstones is greater than .75 (1/1.333, see below), we'll 866| | * take this opportunity to grow the table too. 867| | * 868| | * Immediately after growing, the load factor will be in the range 869| | * .375 .. .469. After shrinking, it will be exactly .5. */ 870| | 871| 17| g_hash_table_set_shift_from_size (hash_table, hash_table->nnodes * 1.333); 872| | 873| 17| if (hash_table->size > old_size) ------------------ | Branch (873:7): [True: 17, False: 0] ------------------ 874| 17| { 875| 17| realloc_arrays (hash_table, is_a_set); 876| 17| memset (&hash_table->hashes[old_size], 0, (hash_table->size - old_size) * sizeof (guint)); 877| | 878| 17| reallocated_buckets_bitmap = g_new0 (guint32, (hash_table->size + 31) / 32); ------------------ | | 307| 17|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 17| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 17|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 17| gsize __n = (gsize) (n_structs); \ | | | | 237| 17| gsize __s = sizeof (struct_type); \ | | | | 238| 17| gpointer __p; \ | | | | 239| 17| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 17] | | | | ------------------ | | | | 240| 17| __p = g_##func (__n); \ | | | | 241| 17| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 17] | | | | ------------------ | | | | 242| 17| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 17| __p = g_##func (__n * __s); \ | | | | 244| 17| else \ | | | | 245| 17| __p = g_##func##_n (__n, __s); \ | | | | 246| 17| __p; \ | | | | 247| 17| })) | | ------------------ ------------------ 879| 17| } 880| 0| else 881| 0| { 882| 0| reallocated_buckets_bitmap = g_new0 (guint32, (old_size + 31) / 32); ------------------ | | 307| 0|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 0| gsize __n = (gsize) (n_structs); \ | | | | 237| 0| gsize __s = sizeof (struct_type); \ | | | | 238| 0| gpointer __p; \ | | | | 239| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 0] | | | | ------------------ | | | | 240| 0| __p = g_##func (__n); \ | | | | 241| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 0| __p; \ | | | | 247| 0| })) | | ------------------ ------------------ 883| 0| } 884| | 885| 17| if (is_a_set) ------------------ | Branch (885:7): [True: 2, False: 15] ------------------ 886| 2| resize_set (hash_table, old_size, reallocated_buckets_bitmap); 887| 15| else 888| 15| resize_map (hash_table, old_size, reallocated_buckets_bitmap); 889| | 890| 17| g_free (reallocated_buckets_bitmap); 891| | 892| 17| if (hash_table->size < old_size) ------------------ | Branch (892:7): [True: 0, False: 17] ------------------ 893| 0| realloc_arrays (hash_table, is_a_set); 894| | 895| 17| hash_table->noccupied = hash_table->nnodes; 896| 17|} ghash.c:g_hash_table_set_shift_from_size: 367| 17|{ 368| 17| gint shift; 369| | 370| 17| shift = g_hash_table_find_closest_shift (size); 371| 17| shift = MAX (shift, HASH_TABLE_MIN_SHIFT); ------------------ | | 822| 17|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 17, False: 0] | | ------------------ ------------------ 372| | 373| 17| g_hash_table_set_shift (hash_table, shift); 374| 17|} ghash.c:g_hash_table_find_closest_shift: 356| 17|{ 357| 17| gint i; 358| | 359| 102| for (i = 0; n; i++) ------------------ | Branch (359:15): [True: 85, False: 17] ------------------ 360| 85| n >>= 1; 361| | 362| 17| return i; 363| 17|} ghash.c:realloc_arrays: 720| 17|{ 721| 17| hash_table->hashes = g_renew (guint, hash_table->hashes, hash_table->size); ------------------ | | 321| 17|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 17| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 17|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 17| gsize __n = (gsize) (n_structs); \ | | | | 251| 17| gsize __s = sizeof (struct_type); \ | | | | 252| 17| gpointer __p = (gpointer) (mem); \ | | | | 253| 17| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 17] | | | | ------------------ | | | | 254| 17| __p = g_##func (__p, __n); \ | | | | 255| 17| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 0, False: 17] | | | | ------------------ | | | | 256| 17| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 0] | | | | | Branch (256:26): [True: 0, False: 0] | | | | ------------------ | | | | 257| 17| __p = g_##func (__p, __n * __s); \ | | | | 258| 17| else \ | | | | 259| 17| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 17| __p; \ | | | | 261| 17| })) | | ------------------ ------------------ 722| 17| hash_table->keys = g_hash_table_realloc_key_or_value_array (hash_table->keys, hash_table->size, hash_table->have_big_keys); 723| | 724| 17| if (is_a_set) ------------------ | Branch (724:7): [True: 2, False: 15] ------------------ 725| 2| hash_table->values = hash_table->keys; 726| 15| else 727| 15| hash_table->values = g_hash_table_realloc_key_or_value_array (hash_table->values, hash_table->size, hash_table->have_big_values); 728| 17|} ghash.c:resize_set: 755| 2|static void fname (GHashTable *hash_table, guint old_size, guint32 *reallocated_buckets_bitmap) \ 756| 2|{ \ 757| 2| guint i; \ 758| 2| \ 759| 26| for (i = 0; i < old_size; i++) \ ------------------ | Branch (759:15): [True: 24, False: 2] ------------------ 760| 24| { \ 761| 24| guint node_hash = hash_table->hashes[i]; \ 762| 24| gpointer key, value G_GNUC_UNUSED; \ 763| 24| \ 764| 24| if (!HASH_IS_REAL (node_hash)) \ ------------------ | | 242| 24|#define HASH_IS_REAL(h_) ((h_) >= 2) ------------------ | Branch (764:11): [True: 0, False: 24] ------------------ 765| 24| { \ 766| 0| /* Clear tombstones */ \ 767| 0| hash_table->hashes[i] = UNUSED_HASH_VALUE; \ ------------------ | | 238| 0|#define UNUSED_HASH_VALUE 0 ------------------ 768| 0| continue; \ 769| 0| } \ 770| 24| \ 771| 24| /* Skip entries relocated through eviction */ \ 772| 24| if (get_status_bit (reallocated_buckets_bitmap, i)) \ ------------------ | Branch (772:11): [True: 8, False: 16] ------------------ 773| 24| continue; \ 774| 24| \ 775| 24| hash_table->hashes[i] = UNUSED_HASH_VALUE; \ ------------------ | | 238| 16|#define UNUSED_HASH_VALUE 0 ------------------ 776| 16| EVICT_KEYVAL (hash_table, i, NULL, NULL, key, value); \ ------------------ | | 828| 16|#define EVICT_KEYVAL(ht, index, key, value, outkey, outvalue) G_STMT_START{ \ | | ------------------ | | | | 874| 16|#define G_STMT_START do | | ------------------ | | 829| 16| (outkey) = g_hash_table_evict_key_or_value ((ht)->keys, (index), (ht)->have_big_keys, (key)); \ | | 830| 16| }G_STMT_END | | ------------------ | | | | 882| 16|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 16] | | | | ------------------ | | ------------------ ------------------ 777| 16| \ 778| 16| for (;;) \ 779| 24| { \ 780| 24| guint hash_val; \ 781| 24| guint replaced_hash; \ 782| 24| guint step = 0; \ 783| 24| \ 784| 24| hash_val = g_hash_table_hash_to_index (hash_table, node_hash); \ 785| 24| \ 786| 24| while (get_status_bit (reallocated_buckets_bitmap, hash_val)) \ ------------------ | Branch (786:18): [True: 0, False: 24] ------------------ 787| 24| { \ 788| 0| step++; \ 789| 0| hash_val += step; \ 790| 0| hash_val &= hash_table->mask; \ 791| 0| } \ 792| 24| \ 793| 24| set_status_bit (reallocated_buckets_bitmap, hash_val); \ 794| 24| \ 795| 24| replaced_hash = hash_table->hashes[hash_val]; \ 796| 24| hash_table->hashes[hash_val] = node_hash; \ 797| 24| if (!HASH_IS_REAL (replaced_hash)) \ ------------------ | | 242| 24|#define HASH_IS_REAL(h_) ((h_) >= 2) ------------------ | Branch (797:15): [True: 16, False: 8] ------------------ 798| 24| { \ 799| 16| ASSIGN_KEYVAL (hash_table, hash_val, key, value); \ ------------------ | | 824| 16|#define ASSIGN_KEYVAL(ht, index, key, value) G_STMT_START{ \ | | ------------------ | | | | 874| 16|#define G_STMT_START do | | ------------------ | | 825| 16| g_hash_table_assign_key_or_value ((ht)->keys, (index), (ht)->have_big_keys, (key)); \ | | 826| 16| }G_STMT_END | | ------------------ | | | | 882| 16|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 16] | | | | ------------------ | | ------------------ ------------------ 800| 16| break; \ 801| 16| } \ 802| 24| \ 803| 24| node_hash = replaced_hash; \ 804| 8| EVICT_KEYVAL (hash_table, hash_val, key, value, key, value); \ ------------------ | | 828| 8|#define EVICT_KEYVAL(ht, index, key, value, outkey, outvalue) G_STMT_START{ \ | | ------------------ | | | | 874| 8|#define G_STMT_START do | | ------------------ | | 829| 8| (outkey) = g_hash_table_evict_key_or_value ((ht)->keys, (index), (ht)->have_big_keys, (key)); \ | | 830| 8| }G_STMT_END | | ------------------ | | | | 882| 8|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 805| 8| } \ 806| 16| } \ 807| 2|} ghash.c:get_status_bit: 740| 827|{ 741| 827| return (bitmap[index / 32] >> (index % 32)) & 1; 742| 827|} ghash.c:g_hash_table_evict_key_or_value: 409| 634|{ 410| |#ifndef USE_SMALL_ARRAYS 411| | is_big = TRUE; 412| |#endif 413| 634| if (is_big) ------------------ | Branch (413:7): [True: 463, False: 171] ------------------ 414| 463| { 415| 463| gpointer r = *(((gpointer *) a) + index); 416| 463| *(((gpointer *) a) + index) = v; 417| 463| return r; 418| 463| } 419| 171| else 420| 171| { 421| 171| gpointer r = GUINT_TO_POINTER (*(((guint *) a) + index)); ------------------ | | 102| 171|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 422| 171| *(((guint *) a) + index) = GPOINTER_TO_UINT (v); ------------------ | | 99| 171|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 423| 171| return r; 424| 171| } 425| 634|} ghash.c:set_status_bit: 746| 329|{ 747| 329| bitmap[index / 32] |= 1U << (index % 32); 748| 329|} ghash.c:resize_map: 755| 15|static void fname (GHashTable *hash_table, guint old_size, guint32 *reallocated_buckets_bitmap) \ 756| 15|{ \ 757| 15| guint i; \ 758| 15| \ 759| 327| for (i = 0; i < old_size; i++) \ ------------------ | Branch (759:15): [True: 312, False: 15] ------------------ 760| 312| { \ 761| 312| guint node_hash = hash_table->hashes[i]; \ 762| 312| gpointer key, value G_GNUC_UNUSED; \ 763| 312| \ 764| 312| if (!HASH_IS_REAL (node_hash)) \ ------------------ | | 242| 312|#define HASH_IS_REAL(h_) ((h_) >= 2) ------------------ | Branch (764:11): [True: 6, False: 306] ------------------ 765| 312| { \ 766| 6| /* Clear tombstones */ \ 767| 6| hash_table->hashes[i] = UNUSED_HASH_VALUE; \ ------------------ | | 238| 6|#define UNUSED_HASH_VALUE 0 ------------------ 768| 6| continue; \ 769| 6| } \ 770| 312| \ 771| 312| /* Skip entries relocated through eviction */ \ 772| 312| if (get_status_bit (reallocated_buckets_bitmap, i)) \ ------------------ | Branch (772:11): [True: 82, False: 224] ------------------ 773| 306| continue; \ 774| 306| \ 775| 306| hash_table->hashes[i] = UNUSED_HASH_VALUE; \ ------------------ | | 238| 224|#define UNUSED_HASH_VALUE 0 ------------------ 776| 224| EVICT_KEYVAL (hash_table, i, NULL, NULL, key, value); \ ------------------ | | 814| 224|#define EVICT_KEYVAL(ht, index, key, value, outkey, outvalue) G_STMT_START{ \ | | ------------------ | | | | 874| 224|#define G_STMT_START do | | ------------------ | | 815| 224| (outkey) = g_hash_table_evict_key_or_value ((ht)->keys, (index), (ht)->have_big_keys, (key)); \ | | 816| 224| (outvalue) = g_hash_table_evict_key_or_value ((ht)->values, (index), (ht)->have_big_values, (value)); \ | | 817| 224| }G_STMT_END | | ------------------ | | | | 882| 224|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 224] | | | | ------------------ | | ------------------ ------------------ 777| 224| \ 778| 224| for (;;) \ 779| 305| { \ 780| 305| guint hash_val; \ 781| 305| guint replaced_hash; \ 782| 305| guint step = 0; \ 783| 305| \ 784| 305| hash_val = g_hash_table_hash_to_index (hash_table, node_hash); \ 785| 305| \ 786| 473| while (get_status_bit (reallocated_buckets_bitmap, hash_val)) \ ------------------ | Branch (786:18): [True: 168, False: 305] ------------------ 787| 305| { \ 788| 168| step++; \ 789| 168| hash_val += step; \ 790| 168| hash_val &= hash_table->mask; \ 791| 168| } \ 792| 305| \ 793| 305| set_status_bit (reallocated_buckets_bitmap, hash_val); \ 794| 305| \ 795| 305| replaced_hash = hash_table->hashes[hash_val]; \ 796| 305| hash_table->hashes[hash_val] = node_hash; \ 797| 305| if (!HASH_IS_REAL (replaced_hash)) \ ------------------ | | 242| 305|#define HASH_IS_REAL(h_) ((h_) >= 2) ------------------ | Branch (797:15): [True: 224, False: 81] ------------------ 798| 305| { \ 799| 224| ASSIGN_KEYVAL (hash_table, hash_val, key, value); \ ------------------ | | 809| 224|#define ASSIGN_KEYVAL(ht, index, key, value) G_STMT_START{ \ | | ------------------ | | | | 874| 224|#define G_STMT_START do | | ------------------ | | 810| 224| g_hash_table_assign_key_or_value ((ht)->keys, (index), (ht)->have_big_keys, (key)); \ | | 811| 224| g_hash_table_assign_key_or_value ((ht)->values, (index), (ht)->have_big_values, (value)); \ | | 812| 224| }G_STMT_END | | ------------------ | | | | 882| 224|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 224] | | | | ------------------ | | ------------------ ------------------ 800| 224| break; \ 801| 224| } \ 802| 305| \ 803| 305| node_hash = replaced_hash; \ 804| 81| EVICT_KEYVAL (hash_table, hash_val, key, value, key, value); \ ------------------ | | 814| 81|#define EVICT_KEYVAL(ht, index, key, value, outkey, outvalue) G_STMT_START{ \ | | ------------------ | | | | 874| 81|#define G_STMT_START do | | ------------------ | | 815| 81| (outkey) = g_hash_table_evict_key_or_value ((ht)->keys, (index), (ht)->have_big_keys, (key)); \ | | 816| 81| (outvalue) = g_hash_table_evict_key_or_value ((ht)->values, (index), (ht)->have_big_values, (value)); \ | | 817| 81| }G_STMT_END | | ------------------ | | | | 882| 81|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 81] | | | | ------------------ | | ------------------ ------------------ 805| 81| } \ 806| 224| } \ 807| 15|} glib_init: 329| 4|{ 330| 4| static gboolean glib_inited; 331| | 332| 4| if (glib_inited) ------------------ | Branch (332:7): [True: 2, False: 2] ------------------ 333| 2| return; 334| | 335| 2| glib_inited = TRUE; ------------------ | | 818| 2|#define TRUE (!FALSE) | | ------------------ | | | | 814| 2|#define FALSE (0) | | ------------------ ------------------ 336| | 337| 2| g_messages_prefixed_init (); 338| 2| g_debug_init (); 339| 2| g_quark_init (); 340| 2| g_error_init (); 341| 2|} glib-init.c:glib_init_ctor: 401| 2|{ 402| 2| glib_init (); 403| 2|} glib-init.c:g_messages_prefixed_init: 297| 2|{ 298| 2| const GDebugKey keys[] = { 299| 2| { "error", G_LOG_LEVEL_ERROR }, 300| 2| { "critical", G_LOG_LEVEL_CRITICAL }, 301| 2| { "warning", G_LOG_LEVEL_WARNING }, 302| 2| { "message", G_LOG_LEVEL_MESSAGE }, 303| 2| { "info", G_LOG_LEVEL_INFO }, 304| 2| { "debug", G_LOG_LEVEL_DEBUG } 305| 2| }; 306| | 307| 2| g_log_msg_prefix = g_parse_debug_envvar ("G_MESSAGES_PREFIXED", keys, G_N_ELEMENTS (keys), g_log_msg_prefix); ------------------ | | 840| 2|#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) ------------------ 308| 2|} glib-init.c:g_parse_debug_envvar: 274| 4|{ 275| 4| const gchar *value; 276| | 277| |#ifdef OS_WIN32 278| | /* "fatal-warnings,fatal-criticals,all,help" is pretty short */ 279| | gchar buffer[100]; 280| | 281| | if (GetEnvironmentVariable (envvar, buffer, 100) < 100) 282| | value = buffer; 283| | else 284| | return 0; 285| |#else 286| 4| value = getenv (envvar); 287| 4|#endif 288| | 289| 4| if (value == NULL) ------------------ | Branch (289:7): [True: 4, False: 0] ------------------ 290| 4| return default_value; 291| | 292| 0| return g_parse_debug_string (value, keys, n_keys); 293| 4|} glib-init.c:g_debug_init: 312| 2|{ 313| 2| const GDebugKey keys[] = { 314| 2| { "gc-friendly", 1 }, 315| 2| {"fatal-warnings", G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL }, 316| 2| {"fatal-criticals", G_LOG_LEVEL_CRITICAL } 317| 2| }; 318| 2| GLogLevelFlags flags; 319| | 320| 2| flags = g_parse_debug_envvar ("G_DEBUG", keys, G_N_ELEMENTS (keys), 0); ------------------ | | 840| 2|#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) ------------------ 321| | 322| 2| g_log_always_fatal |= flags & G_LOG_LEVEL_MASK; 323| | 324| 2| g_mem_gc_friendly = flags & 1; 325| 2|} glib__private__: 34| 2|{ 35| 2| static GLibPrivateVTable table = { 36| 2| g_wakeup_new, 37| 2| g_wakeup_free, 38| 2| g_wakeup_get_pollfd, 39| 2| g_wakeup_signal, 40| 2| g_wakeup_acknowledge, 41| | 42| 2| g_get_worker_context, 43| | 44| 2| g_check_setuid, 45| 2| g_main_context_new_with_next_id, 46| | 47| 2| g_dir_open_with_errno, 48| 2| g_dir_new_from_dirp, 49| | 50| 2| glib_init, 51| | 52| |#ifdef G_OS_WIN32 53| | g_win32_stat_utf8, 54| | g_win32_lstat_utf8, 55| | g_win32_readlink_utf8, 56| | g_win32_fstat, 57| |#endif 58| 2| }; 59| | 60| 2| return &table; 61| 2|} g_get_real_time: 2820| 21|{ 2821| 21|#ifndef G_OS_WIN32 2822| 21| struct timeval r; 2823| | 2824| | /* this is required on alpha, there the timeval structs are ints 2825| | * not longs and a cast only would fail horribly */ 2826| 21| gettimeofday (&r, NULL); 2827| | 2828| 21| return (((gint64) r.tv_sec) * 1000000) + r.tv_usec; 2829| |#else 2830| | FILETIME ft; 2831| | guint64 time64; 2832| | 2833| | GetSystemTimeAsFileTime (&ft); 2834| | memmove (&time64, &ft, sizeof (FILETIME)); 2835| | 2836| | /* Convert from 100s of nanoseconds since 1601-01-01 2837| | * to Unix epoch. This is Y2038 safe. 2838| | */ 2839| | time64 -= G_GINT64_CONSTANT (116444736000000000); 2840| | time64 /= 10; 2841| | 2842| | return time64; 2843| |#endif 2844| 21|} g_malloc: 101| 527k|{ 102| 527k| if (G_LIKELY (n_bytes)) ------------------ | | 1024| 527k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 527k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 527k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 527k| int _g_boolean_var_; \ | | | | 1018| 527k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 527k, False: 0] | | | | ------------------ | | | | 1019| 527k| _g_boolean_var_ = 1; \ | | | | 1020| 527k| else \ | | | | 1021| 527k| _g_boolean_var_ = 0; \ | | | | 1022| 527k| _g_boolean_var_; \ | | | | 1023| 527k|}) | | ------------------ | | | Branch (1024:24): [True: 527k, False: 0] | | ------------------ ------------------ 103| 527k| { 104| 527k| gpointer mem; 105| | 106| 527k| mem = malloc (n_bytes); 107| 527k| TRACE (GLIB_MEM_ALLOC((void*) mem, (unsigned int) n_bytes, 0, 0)); 108| 527k| if (mem) ------------------ | Branch (108:11): [True: 527k, False: 0] ------------------ 109| 527k| return mem; 110| | 111| 527k| g_error ("%s: failed to allocate %"G_GSIZE_FORMAT" bytes", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 527k| } G_STMT_END | | ------------------ | | | | 882| 527k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 112| 0| G_STRLOC, n_bytes); 113| 0| } 114| | 115| 0| TRACE(GLIB_MEM_ALLOC((void*) NULL, (int) n_bytes, 0, 0)); 116| | 117| | return NULL; 118| 527k|} g_malloc0: 131| 274k|{ 132| 274k| if (G_LIKELY (n_bytes)) ------------------ | | 1024| 274k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 274k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 274k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 274k| int _g_boolean_var_; \ | | | | 1018| 274k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 274k, False: 0] | | | | ------------------ | | | | 1019| 274k| _g_boolean_var_ = 1; \ | | | | 1020| 274k| else \ | | | | 1021| 274k| _g_boolean_var_ = 0; \ | | | | 1022| 274k| _g_boolean_var_; \ | | | | 1023| 274k|}) | | ------------------ | | | Branch (1024:24): [True: 274k, False: 0] | | ------------------ ------------------ 133| 274k| { 134| 274k| gpointer mem; 135| | 136| 274k| mem = calloc (1, n_bytes); 137| 274k| TRACE (GLIB_MEM_ALLOC((void*) mem, (unsigned int) n_bytes, 1, 0)); 138| 274k| if (mem) ------------------ | Branch (138:11): [True: 274k, False: 0] ------------------ 139| 274k| return mem; 140| | 141| 274k| g_error ("%s: failed to allocate %"G_GSIZE_FORMAT" bytes", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 274k| } G_STMT_END | | ------------------ | | | | 882| 274k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 142| 0| G_STRLOC, n_bytes); 143| 0| } 144| | 145| 0| TRACE(GLIB_MEM_ALLOC((void*) NULL, (int) n_bytes, 1, 0)); 146| | 147| | return NULL; 148| 274k|} g_realloc: 166| 535k|{ 167| 535k| gpointer newmem; 168| | 169| 535k| if (G_LIKELY (n_bytes)) ------------------ | | 1024| 535k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 535k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 535k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 535k| int _g_boolean_var_; \ | | | | 1018| 535k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 535k, False: 0] | | | | ------------------ | | | | 1019| 535k| _g_boolean_var_ = 1; \ | | | | 1020| 535k| else \ | | | | 1021| 535k| _g_boolean_var_ = 0; \ | | | | 1022| 535k| _g_boolean_var_; \ | | | | 1023| 535k|}) | | ------------------ | | | Branch (1024:24): [True: 535k, False: 0] | | ------------------ ------------------ 170| 535k| { 171| 535k| newmem = realloc (mem, n_bytes); 172| 535k| TRACE (GLIB_MEM_REALLOC((void*) newmem, (void*)mem, (unsigned int) n_bytes, 0)); 173| 535k| if (newmem) ------------------ | Branch (173:11): [True: 535k, False: 0] ------------------ 174| 535k| return newmem; 175| | 176| 535k| g_error ("%s: failed to allocate %"G_GSIZE_FORMAT" bytes", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 535k| } G_STMT_END | | ------------------ | | | | 882| 535k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 177| 0| G_STRLOC, n_bytes); 178| 0| } 179| | 180| 0| free (mem); 181| | 182| 0| TRACE (GLIB_MEM_REALLOC((void*) NULL, (void*)mem, 0, 0)); 183| | 184| | return NULL; 185| 535k|} g_free: 198| 951k|{ 199| 951k| free (mem); 200| 951k| TRACE(GLIB_MEM_FREE((void*) mem)); 201| 951k|} g_malloc_n: 337| 13|{ 338| 13| if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) ------------------ | | 321| 13|#define SIZE_OVERFLOWS(a,b) (G_UNLIKELY ((b) > 0 && (a) > G_MAXSIZE / (b))) | | ------------------ | | | | 1025| 13|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 13| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 13|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 13| int _g_boolean_var_; \ | | | | | | 1018| 39| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 13, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 13] | | | | | | ------------------ | | | | | | 1019| 13| _g_boolean_var_ = 1; \ | | | | | | 1020| 13| else \ | | | | | | 1021| 13| _g_boolean_var_ = 0; \ | | | | | | 1022| 13| _g_boolean_var_; \ | | | | | | 1023| 13|}) | | | | ------------------ | | ------------------ | | | Branch (321:29): [True: 0, False: 13] | | ------------------ ------------------ 339| 0| { 340| 0| g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 341| 0| G_STRLOC, n_blocks, n_block_bytes); 342| 0| } 343| | 344| 13| return g_malloc (n_blocks * n_block_bytes); 345| 13|} g_malloc0_n: 361| 39|{ 362| 39| if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) ------------------ | | 321| 39|#define SIZE_OVERFLOWS(a,b) (G_UNLIKELY ((b) > 0 && (a) > G_MAXSIZE / (b))) | | ------------------ | | | | 1025| 39|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 39| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 39|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 39| int _g_boolean_var_; \ | | | | | | 1018| 117| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 39, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 39] | | | | | | ------------------ | | | | | | 1019| 39| _g_boolean_var_ = 1; \ | | | | | | 1020| 39| else \ | | | | | | 1021| 39| _g_boolean_var_ = 0; \ | | | | | | 1022| 39| _g_boolean_var_; \ | | | | | | 1023| 39|}) | | | | ------------------ | | ------------------ | | | Branch (321:29): [True: 0, False: 39] | | ------------------ ------------------ 363| 0| { 364| 0| g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 365| 0| G_STRLOC, n_blocks, n_block_bytes); 366| 0| } 367| | 368| 39| return g_malloc0 (n_blocks * n_block_bytes); 369| 39|} g_realloc_n: 387| 182|{ 388| 182| if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) ------------------ | | 321| 182|#define SIZE_OVERFLOWS(a,b) (G_UNLIKELY ((b) > 0 && (a) > G_MAXSIZE / (b))) | | ------------------ | | | | 1025| 182|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 182| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 182|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 182| int _g_boolean_var_; \ | | | | | | 1018| 546| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 182, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 182] | | | | | | ------------------ | | | | | | 1019| 182| _g_boolean_var_ = 1; \ | | | | | | 1020| 182| else \ | | | | | | 1021| 182| _g_boolean_var_ = 0; \ | | | | | | 1022| 182| _g_boolean_var_; \ | | | | | | 1023| 182|}) | | | | ------------------ | | ------------------ | | | Branch (321:29): [True: 0, False: 182] | | ------------------ ------------------ 389| 0| { 390| 0| g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 391| 0| G_STRLOC, n_blocks, n_block_bytes); 392| 0| } 393| | 394| 182| return g_realloc (mem, n_blocks * n_block_bytes); 395| 182|} garray.c:g_steal_pointer: 210| 46.6k|{ 211| 46.6k| gpointer *ptr = (gpointer *) pp; 212| 46.6k| gpointer ref; 213| | 214| 46.6k| ref = *ptr; 215| 46.6k| *ptr = NULL; 216| | 217| 46.6k| return ref; 218| 46.6k|} gthread.c:g_steal_pointer: 210| 2|{ 211| 2| gpointer *ptr = (gpointer *) pp; 212| 2| gpointer ref; 213| | 214| 2| ref = *ptr; 215| 2| *ptr = NULL; 216| | 217| 2| return ref; 218| 2|} g_logv: 1289| 257k|{ 1290| 257k| gboolean was_fatal = (log_level & G_LOG_FLAG_FATAL) != 0; 1291| 257k| gboolean was_recursion = (log_level & G_LOG_FLAG_RECURSION) != 0; 1292| 257k| gchar buffer[1025], *msg, *msg_alloc = NULL; 1293| 257k| gint i; 1294| | 1295| 257k| log_level &= G_LOG_LEVEL_MASK; 1296| 257k| if (!log_level) ------------------ | Branch (1296:7): [True: 0, False: 257k] ------------------ 1297| 0| return; 1298| | 1299| 257k| if (log_level & G_LOG_FLAG_RECURSION) ------------------ | Branch (1299:7): [True: 0, False: 257k] ------------------ 1300| 0| { 1301| | /* we use a stack buffer of fixed size, since we're likely 1302| | * in an out-of-memory situation 1303| | */ 1304| 0| gsize size G_GNUC_UNUSED; 1305| | 1306| 0| size = _g_vsnprintf (buffer, 1024, format, args); ------------------ | | 52| 0|#define _g_vsnprintf _g_gnulib_vsnprintf ------------------ 1307| 0| msg = buffer; 1308| 0| } 1309| 257k| else 1310| 257k| msg = msg_alloc = g_strdup_vprintf (format, args); 1311| | 1312| 257k| if (expected_messages) ------------------ | Branch (1312:7): [True: 0, False: 257k] ------------------ 1313| 0| { 1314| 0| GTestExpectedMessage *expected = expected_messages->data; 1315| | 1316| 0| if (g_strcmp0 (expected->log_domain, log_domain) == 0 && ------------------ | Branch (1316:11): [True: 0, False: 0] ------------------ 1317| 0| ((log_level & expected->log_level) == expected->log_level) && ------------------ | Branch (1317:11): [True: 0, False: 0] ------------------ 1318| 0| g_pattern_match_simple (expected->pattern, msg)) ------------------ | Branch (1318:11): [True: 0, False: 0] ------------------ 1319| 0| { 1320| 0| expected_messages = g_slist_delete_link (expected_messages, 1321| 0| expected_messages); 1322| 0| g_free (expected->log_domain); 1323| 0| g_free (expected->pattern); 1324| 0| g_free (expected); 1325| 0| g_free (msg_alloc); 1326| 0| return; 1327| 0| } 1328| 0| else if ((log_level & G_LOG_LEVEL_DEBUG) != G_LOG_LEVEL_DEBUG) ------------------ | Branch (1328:16): [True: 0, False: 0] ------------------ 1329| 0| { 1330| 0| gchar level_prefix[STRING_BUFFER_SIZE]; 1331| 0| gchar *expected_message; 1332| | 1333| 0| mklevel_prefix (level_prefix, expected->log_level, FALSE); ------------------ | | 814| 0|#define FALSE (0) ------------------ 1334| 0| expected_message = g_strdup_printf ("Did not see expected message %s-%s: %s", 1335| 0| expected->log_domain ? expected->log_domain : "**", ------------------ | Branch (1335:47): [True: 0, False: 0] ------------------ 1336| 0| level_prefix, expected->pattern); 1337| 0| g_log_default_handler (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, expected_message, NULL); 1338| 0| g_free (expected_message); 1339| | 1340| 0| log_level |= G_LOG_FLAG_FATAL; 1341| 0| } 1342| 0| } 1343| | 1344| 514k| for (i = g_bit_nth_msf (log_level, -1); i >= 0; i = g_bit_nth_msf (log_level, i)) ------------------ | | 369| 257k|#define g_bit_nth_msf(mask, nth_bit) g_bit_nth_msf_impl(mask, nth_bit) ------------------ for (i = g_bit_nth_msf (log_level, -1); i >= 0; i = g_bit_nth_msf (log_level, i)) ------------------ | | 369| 257k|#define g_bit_nth_msf(mask, nth_bit) g_bit_nth_msf_impl(mask, nth_bit) ------------------ | Branch (1344:43): [True: 257k, False: 257k] ------------------ 1345| 257k| { 1346| 257k| GLogLevelFlags test_level; 1347| | 1348| 257k| test_level = 1L << i; 1349| 257k| if (log_level & test_level) ------------------ | Branch (1349:11): [True: 257k, False: 0] ------------------ 1350| 257k| { 1351| 257k| GLogDomain *domain; 1352| 257k| GLogFunc log_func; 1353| 257k| GLogLevelFlags domain_fatal_mask; 1354| 257k| gpointer data = NULL; 1355| 257k| gboolean masquerade_fatal = FALSE; ------------------ | | 814| 257k|#define FALSE (0) ------------------ 1356| 257k| guint depth; 1357| | 1358| 257k| if (was_fatal) ------------------ | Branch (1358:8): [True: 0, False: 257k] ------------------ 1359| 0| test_level |= G_LOG_FLAG_FATAL; 1360| 257k| if (was_recursion) ------------------ | Branch (1360:8): [True: 0, False: 257k] ------------------ 1361| 0| test_level |= G_LOG_FLAG_RECURSION; 1362| | 1363| | /* check recursion and lookup handler */ 1364| 257k| g_mutex_lock (&g_messages_lock); 1365| 257k| depth = GPOINTER_TO_UINT (g_private_get (&g_log_depth)); ------------------ | | 99| 257k|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 1366| 257k| domain = g_log_find_domain_L (log_domain ? log_domain : ""); ------------------ | Branch (1366:34): [True: 257k, False: 0] ------------------ 1367| 257k| if (depth) ------------------ | Branch (1367:8): [True: 0, False: 257k] ------------------ 1368| 0| test_level |= G_LOG_FLAG_RECURSION; 1369| 257k| depth++; 1370| 257k| domain_fatal_mask = domain ? domain->fatal_mask : G_LOG_FATAL_MASK; ------------------ | | 71| 514k|#define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR) ------------------ | Branch (1370:24): [True: 0, False: 257k] ------------------ 1371| 257k| if ((domain_fatal_mask | g_log_always_fatal) & test_level) ------------------ | Branch (1371:8): [True: 0, False: 257k] ------------------ 1372| 0| test_level |= G_LOG_FLAG_FATAL; 1373| 257k| if (test_level & G_LOG_FLAG_RECURSION) ------------------ | Branch (1373:8): [True: 0, False: 257k] ------------------ 1374| 0| log_func = _g_log_fallback_handler; 1375| 257k| else 1376| 257k| log_func = g_log_domain_get_handler_L (domain, test_level, &data); 1377| 257k| domain = NULL; 1378| 257k| g_mutex_unlock (&g_messages_lock); 1379| | 1380| 257k| g_private_set (&g_log_depth, GUINT_TO_POINTER (depth)); ------------------ | | 102| 257k|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 1381| | 1382| 257k| log_func (log_domain, test_level, msg, data); 1383| | 1384| 257k| if ((test_level & G_LOG_FLAG_FATAL) ------------------ | Branch (1384:15): [True: 0, False: 257k] ------------------ 1385| 0| && !(test_level & G_LOG_LEVEL_ERROR)) ------------------ | Branch (1385:18): [True: 0, False: 0] ------------------ 1386| 0| { 1387| 0| masquerade_fatal = fatal_log_func ------------------ | Branch (1387:34): [True: 0, False: 0] ------------------ 1388| 0| && !fatal_log_func (log_domain, test_level, msg, fatal_log_data); ------------------ | Branch (1388:20): [True: 0, False: 0] ------------------ 1389| 0| } 1390| | 1391| 257k| if ((test_level & G_LOG_FLAG_FATAL) && !masquerade_fatal) ------------------ | Branch (1391:15): [True: 0, False: 257k] | Branch (1391:50): [True: 0, False: 0] ------------------ 1392| 0| { 1393| | /* MessageBox is allowed on UWP apps only when building against 1394| | * the debug CRT, which will set -D_DEBUG */ 1395| |#if defined(G_OS_WIN32) && (defined(_DEBUG) || !defined(G_WINAPI_ONLY_APP)) 1396| | if (win32_keep_fatal_message) 1397| | { 1398| | WCHAR *wide_msg; 1399| | 1400| | wide_msg = g_utf8_to_utf16 (fatal_msg_buf, -1, NULL, NULL, NULL); 1401| | 1402| | MessageBoxW (NULL, wide_msg, NULL, 1403| | MB_ICONERROR | MB_SETFOREGROUND); 1404| | 1405| | g_free (wide_msg); 1406| | } 1407| |#endif 1408| | 1409| 0| _g_log_abort (!(test_level & G_LOG_FLAG_RECURSION)); 1410| 0| } 1411| | 1412| 257k| depth--; 1413| 257k| g_private_set (&g_log_depth, GUINT_TO_POINTER (depth)); ------------------ | | 102| 257k|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 1414| 257k| } 1415| 257k| } 1416| | 1417| 257k| g_free (msg_alloc); 1418| 257k|} g_log: 1447| 257k|{ 1448| 257k| va_list args; 1449| | 1450| 257k| va_start (args, format); 1451| 257k| g_logv (log_domain, log_level, format, args); 1452| | va_end (args); 1453| 257k|} g_log_structured_array: 1940| 257k|{ 1941| 257k| GLogWriterFunc writer_func; 1942| 257k| gpointer writer_user_data; 1943| 257k| gboolean recursion; 1944| 257k| guint depth; 1945| | 1946| 257k| if (n_fields == 0) ------------------ | Branch (1946:7): [True: 0, False: 257k] ------------------ 1947| 0| return; 1948| | 1949| | /* Check for recursion and look up the writer function. */ 1950| 257k| depth = GPOINTER_TO_UINT (g_private_get (&g_log_structured_depth)); ------------------ | | 99| 257k|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 1951| 257k| recursion = (depth > 0); 1952| | 1953| 257k| g_mutex_lock (&g_messages_lock); 1954| | 1955| 257k| writer_func = recursion ? _g_log_writer_fallback : log_writer_func; ------------------ | Branch (1955:17): [True: 0, False: 257k] ------------------ 1956| 257k| writer_user_data = log_writer_user_data; 1957| | 1958| 257k| g_mutex_unlock (&g_messages_lock); 1959| | 1960| | /* Write the log entry. */ 1961| 257k| g_private_set (&g_log_structured_depth, GUINT_TO_POINTER (++depth)); ------------------ | | 102| 257k|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 1962| | 1963| 257k| g_assert (writer_func != NULL); ------------------ | | 231| 257k|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 257k|#define G_STMT_START do | | ------------------ | | 232| 257k| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 257k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 257k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 257k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 257k| int _g_boolean_var_; \ | | | | | | 1018| 257k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 257k, False: 0] | | | | | | ------------------ | | | | | | 1019| 257k| _g_boolean_var_ = 1; \ | | | | | | 1020| 257k| else \ | | | | | | 1021| 257k| _g_boolean_var_ = 0; \ | | | | | | 1022| 257k| _g_boolean_var_; \ | | | | | | 1023| 257k|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 257k, False: 0] | | | | ------------------ | | ------------------ | | 233| 257k| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 257k| } G_STMT_END | | ------------------ | | | | 882| 257k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 257k] | | | | ------------------ | | ------------------ ------------------ 1964| 257k| writer_func (log_level, fields, n_fields, writer_user_data); 1965| | 1966| 257k| g_private_set (&g_log_structured_depth, GUINT_TO_POINTER (--depth)); ------------------ | | 102| 257k|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 1967| | 1968| | /* Abort if the message was fatal. */ 1969| 257k| if (log_level & G_LOG_FATAL_MASK) ------------------ | | 71| 257k|#define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR) ------------------ | Branch (1969:7): [True: 0, False: 257k] ------------------ 1970| 0| _g_log_abort (!(log_level & G_LOG_FLAG_RECURSION)); 1971| 257k|} g_log_writer_default: 2751| 257k|{ 2752| 257k| static gsize initialized = 0; 2753| 257k| static gboolean stderr_is_journal = FALSE; ------------------ | | 814| 257k|#define FALSE (0) ------------------ 2754| | 2755| 257k| g_return_val_if_fail (fields != NULL, G_LOG_WRITER_UNHANDLED); ------------------ | | 643| 257k| G_STMT_START { \ | | ------------------ | | | | 874| 257k|#define G_STMT_START do | | ------------------ | | 644| 257k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 257k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 257k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 257k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 257k| int _g_boolean_var_; \ | | | | | | 1018| 257k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 257k, False: 0] | | | | | | ------------------ | | | | | | 1019| 257k| _g_boolean_var_ = 1; \ | | | | | | 1020| 257k| else \ | | | | | | 1021| 257k| _g_boolean_var_ = 0; \ | | | | | | 1022| 257k| _g_boolean_var_; \ | | | | | | 1023| 257k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 257k, False: 0] | | | | ------------------ | | ------------------ | | 645| 257k| { } \ | | 646| 257k| else \ | | 647| 257k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 257k| } G_STMT_END | | ------------------ | | | | 882| 257k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 257k] | | | | ------------------ | | ------------------ ------------------ 2756| 257k| g_return_val_if_fail (n_fields > 0, G_LOG_WRITER_UNHANDLED); ------------------ | | 643| 257k| G_STMT_START { \ | | ------------------ | | | | 874| 257k|#define G_STMT_START do | | ------------------ | | 644| 257k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 257k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 257k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 257k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 257k| int _g_boolean_var_; \ | | | | | | 1018| 257k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 257k, False: 0] | | | | | | ------------------ | | | | | | 1019| 257k| _g_boolean_var_ = 1; \ | | | | | | 1020| 257k| else \ | | | | | | 1021| 257k| _g_boolean_var_ = 0; \ | | | | | | 1022| 257k| _g_boolean_var_; \ | | | | | | 1023| 257k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 257k, False: 0] | | | | ------------------ | | ------------------ | | 645| 257k| { } \ | | 646| 257k| else \ | | 647| 257k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 257k| } G_STMT_END | | ------------------ | | | | 882| 257k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 257k] | | | | ------------------ | | ------------------ ------------------ 2757| | 2758| 257k| if (should_drop_message (log_level, NULL, fields, n_fields)) ------------------ | Branch (2758:7): [True: 257k, False: 0] ------------------ 2759| 257k| return G_LOG_WRITER_HANDLED; 2760| | 2761| | /* Mark messages as fatal if they have a level set in 2762| | * g_log_set_always_fatal(). 2763| | */ 2764| 0| if ((log_level & g_log_always_fatal) && !log_is_old_api (fields, n_fields)) ------------------ | Branch (2764:7): [True: 0, False: 0] | Branch (2764:43): [True: 0, False: 0] ------------------ 2765| 0| log_level |= G_LOG_FLAG_FATAL; 2766| | 2767| | /* Try logging to the systemd journal as first choice. */ 2768| 0| if (g_once_init_enter (&initialized)) ------------------ | | 257| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | | Branch (257:3): [True: 0, False: 0] | | ------------------ | | 258| 0| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 259| 0| (void) (0 ? (gpointer) *(location) : NULL); \ | | ------------------ | | | Branch (259:13): [Folded, False: 0] | | ------------------ | | 260| 0| (!g_atomic_pointer_get (location) && \ | | ------------------ | | | | 113| 0| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 0| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 0|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 0| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 0|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 0| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 0| gapg_temp_newval; \ | | | | 119| 0| })) | | ------------------ | | | Branch (260:6): [True: 0, False: 0] | | ------------------ | | 261| 0| g_once_init_enter (location)); \ | | ------------------ | | | Branch (261:6): [True: 0, False: 0] | | ------------------ | | 262| 0| })) ------------------ 2769| 0| { 2770| 0| stderr_is_journal = g_log_writer_is_journald (fileno (stderr)); 2771| 0| g_once_init_leave (&initialized, TRUE); ------------------ | | 264| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 265| 0| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 266| 0| 0 ? (void) (*(location) = (result)) : (void) 0; \ | | ------------------ | | | Branch (266:5): [Folded, False: 0] | | ------------------ | | 267| 0| g_once_init_leave ((location), (gsize) (result)); \ | | 268| 0| })) ------------------ 2772| 0| } 2773| | 2774| 0| if (stderr_is_journal && ------------------ | Branch (2774:7): [True: 0, False: 0] ------------------ 2775| 0| g_log_writer_journald (log_level, fields, n_fields, user_data) == ------------------ | Branch (2775:7): [True: 0, False: 0] ------------------ 2776| 0| G_LOG_WRITER_HANDLED) 2777| 0| goto handled; 2778| | 2779| | /* FIXME: Add support for the Windows log. */ 2780| | 2781| 0| if (g_log_writer_standard_streams (log_level, fields, n_fields, user_data) == ------------------ | Branch (2781:7): [True: 0, False: 0] ------------------ 2782| 0| G_LOG_WRITER_HANDLED) 2783| 0| goto handled; 2784| | 2785| 0| return G_LOG_WRITER_UNHANDLED; 2786| | 2787| 0|handled: 2788| | /* Abort if the message was fatal. */ 2789| 0| if (log_level & G_LOG_FLAG_FATAL) ------------------ | Branch (2789:7): [True: 0, False: 0] ------------------ 2790| 0| { 2791| | /* MessageBox is allowed on UWP apps only when building against 2792| | * the debug CRT, which will set -D_DEBUG */ 2793| |#if defined(G_OS_WIN32) && (defined(_DEBUG) || !defined(G_WINAPI_ONLY_APP)) 2794| | if (!g_test_initialized ()) 2795| | { 2796| | WCHAR *wide_msg; 2797| | 2798| | wide_msg = g_utf8_to_utf16 (fatal_msg_buf, -1, NULL, NULL, NULL); 2799| | 2800| | MessageBoxW (NULL, wide_msg, NULL, MB_ICONERROR | MB_SETFOREGROUND); 2801| | 2802| | g_free (wide_msg); 2803| | } 2804| |#endif /* !G_OS_WIN32 */ 2805| | 2806| 0| _g_log_abort (!(log_level & G_LOG_FLAG_RECURSION)); 2807| 0| } 2808| | 2809| 0| return G_LOG_WRITER_HANDLED; 2810| 0|} g_log_default_handler: 3197| 257k|{ 3198| 257k| GLogField fields[4]; 3199| 257k| int n_fields = 0; 3200| | 3201| | /* we can be called externally with recursion for whatever reason */ 3202| 257k| if (log_level & G_LOG_FLAG_RECURSION) ------------------ | Branch (3202:7): [True: 0, False: 257k] ------------------ 3203| 0| { 3204| 0| _g_log_fallback_handler (log_domain, log_level, message, unused_data); 3205| 0| return; 3206| 0| } 3207| | 3208| 257k| fields[0].key = "GLIB_OLD_LOG_API"; 3209| 257k| fields[0].value = "1"; 3210| 257k| fields[0].length = -1; 3211| 257k| n_fields++; 3212| | 3213| 257k| fields[1].key = "MESSAGE"; 3214| 257k| fields[1].value = message; 3215| 257k| fields[1].length = -1; 3216| 257k| n_fields++; 3217| | 3218| 257k| fields[2].key = "PRIORITY"; 3219| 257k| fields[2].value = log_level_to_priority (log_level); 3220| 257k| fields[2].length = -1; 3221| 257k| n_fields++; 3222| | 3223| 257k| if (log_domain) ------------------ | Branch (3223:7): [True: 257k, False: 0] ------------------ 3224| 257k| { 3225| 257k| fields[3].key = "GLIB_DOMAIN"; 3226| 257k| fields[3].value = log_domain; 3227| 257k| fields[3].length = -1; 3228| 257k| n_fields++; 3229| 257k| } 3230| | 3231| | /* Print out via the structured log API, but drop any fatal flags since we 3232| | * have already handled them. The fatal handling in the structured logging 3233| | * API is more coarse-grained than in the old g_log() API, so we don't want 3234| | * to use it here. 3235| | */ 3236| 257k| g_log_structured_array (log_level & ~G_LOG_FLAG_FATAL, fields, n_fields); 3237| 257k|} gmessages.c:g_log_find_domain_L: 614| 257k|{ 615| 257k| GLogDomain *domain; 616| | 617| 257k| domain = g_log_domains; 618| 257k| while (domain) ------------------ | Branch (618:10): [True: 0, False: 257k] ------------------ 619| 0| { 620| 0| if (strcmp (domain->log_domain, log_domain) == 0) ------------------ | Branch (620:11): [True: 0, False: 0] ------------------ 621| 0| return domain; 622| 0| domain = domain->next; 623| 0| } 624| 257k| return NULL; 625| 257k|} gmessages.c:g_log_domain_get_handler_L: 676| 257k|{ 677| 257k| if (domain && log_level) ------------------ | Branch (677:7): [True: 0, False: 257k] | Branch (677:17): [True: 0, False: 0] ------------------ 678| 0| { 679| 0| GLogHandler *handler; 680| | 681| 0| handler = domain->handlers; 682| 0| while (handler) ------------------ | Branch (682:14): [True: 0, False: 0] ------------------ 683| 0| { 684| 0| if ((handler->log_level & log_level) == log_level) ------------------ | Branch (684:8): [True: 0, False: 0] ------------------ 685| 0| { 686| 0| *data = handler->data; 687| 0| return handler->log_func; 688| 0| } 689| 0| handler = handler->next; 690| 0| } 691| 0| } 692| | 693| 257k| *data = default_log_data; 694| 257k| return default_log_func; 695| 257k|} gmessages.c:log_level_to_priority: 1460| 257k|{ 1461| 257k| if (log_level & G_LOG_LEVEL_ERROR) ------------------ | Branch (1461:7): [True: 0, False: 257k] ------------------ 1462| 0| return "3"; 1463| 257k| else if (log_level & G_LOG_LEVEL_CRITICAL) ------------------ | Branch (1463:12): [True: 0, False: 257k] ------------------ 1464| 0| return "4"; 1465| 257k| else if (log_level & G_LOG_LEVEL_WARNING) ------------------ | Branch (1465:12): [True: 0, False: 257k] ------------------ 1466| 0| return "4"; 1467| 257k| else if (log_level & G_LOG_LEVEL_MESSAGE) ------------------ | Branch (1467:12): [True: 0, False: 257k] ------------------ 1468| 0| return "5"; 1469| 257k| else if (log_level & G_LOG_LEVEL_INFO) ------------------ | Branch (1469:12): [True: 0, False: 257k] ------------------ 1470| 0| return "6"; 1471| 257k| else if (log_level & G_LOG_LEVEL_DEBUG) ------------------ | Branch (1471:12): [True: 257k, False: 0] ------------------ 1472| 257k| return "7"; 1473| | 1474| | /* Default to LOG_NOTICE for custom log levels. */ 1475| 0| return "5"; 1476| 257k|} gmessages.c:should_drop_message: 2636| 257k|{ 2637| | /* Disable debug message output unless specified in G_MESSAGES_DEBUG. */ 2638| 257k| if (!(log_level & DEFAULT_LEVELS) && !(log_level >> G_LOG_LEVEL_USER_SHIFT)) ------------------ | | 1157| 257k|#define DEFAULT_LEVELS (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE) ------------------ if (!(log_level & DEFAULT_LEVELS) && !(log_level >> G_LOG_LEVEL_USER_SHIFT)) ------------------ | | 49| 257k|#define G_LOG_LEVEL_USER_SHIFT (8) ------------------ | Branch (2638:7): [True: 257k, False: 0] | Branch (2638:40): [True: 257k, False: 0] ------------------ 2639| 257k| { 2640| 257k| const gchar *domains; 2641| 257k| gsize i; 2642| | 2643| 257k| domains = g_getenv ("G_MESSAGES_DEBUG"); 2644| | 2645| 257k| if ((log_level & INFO_LEVELS) == 0 || ------------------ | | 1159| 257k|#define INFO_LEVELS (G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG) ------------------ | Branch (2645:11): [True: 0, False: 257k] ------------------ 2646| 257k| domains == NULL) ------------------ | Branch (2646:11): [True: 257k, False: 0] ------------------ 2647| 257k| return TRUE; ------------------ | | 818| 257k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 257k|#define FALSE (0) | | ------------------ ------------------ 2648| | 2649| 0| if (log_domain == NULL) ------------------ | Branch (2649:11): [True: 0, False: 0] ------------------ 2650| 0| { 2651| 0| for (i = 0; i < n_fields; i++) ------------------ | Branch (2651:23): [True: 0, False: 0] ------------------ 2652| 0| { 2653| 0| if (g_strcmp0 (fields[i].key, "GLIB_DOMAIN") == 0) ------------------ | Branch (2653:19): [True: 0, False: 0] ------------------ 2654| 0| { 2655| 0| log_domain = fields[i].value; 2656| 0| break; 2657| 0| } 2658| 0| } 2659| 0| } 2660| | 2661| 0| if (strcmp (domains, "all") != 0 && ------------------ | Branch (2661:11): [True: 0, False: 0] ------------------ 2662| 0| (log_domain == NULL || !strstr (domains, log_domain))) ------------------ | Branch (2662:12): [True: 0, False: 0] | Branch (2662:34): [True: 0, False: 0] ------------------ 2663| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 2664| 0| } 2665| | 2666| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 2667| 257k|} _g_gnulib_printf_fetchargs: 39| 257k|{ 40| 257k| size_t i; 41| 257k| argument *ap; 42| | 43| 741k| for (i = 0, ap = &a->arg[0]; i < a->count; i++, ap++) ------------------ | Branch (43:32): [True: 484k, False: 257k] ------------------ 44| 484k| switch (ap->type) 45| 484k| { 46| 0| case TYPE_SCHAR: ------------------ | Branch (46:7): [True: 0, False: 484k] ------------------ 47| 0| ap->a.a_schar = va_arg (args, /*signed char*/ int); 48| 0| break; 49| 0| case TYPE_UCHAR: ------------------ | Branch (49:7): [True: 0, False: 484k] ------------------ 50| 0| ap->a.a_uchar = va_arg (args, /*unsigned char*/ int); 51| 0| break; 52| 0| case TYPE_SHORT: ------------------ | Branch (52:7): [True: 0, False: 484k] ------------------ 53| 0| ap->a.a_short = va_arg (args, /*short*/ int); 54| 0| break; 55| 0| case TYPE_USHORT: ------------------ | Branch (55:7): [True: 0, False: 484k] ------------------ 56| 0| ap->a.a_ushort = va_arg (args, /*unsigned short*/ int); 57| 0| break; 58| 0| case TYPE_INT: ------------------ | Branch (58:7): [True: 0, False: 484k] ------------------ 59| 0| ap->a.a_int = va_arg (args, int); 60| 0| break; 61| 327k| case TYPE_UINT: ------------------ | Branch (61:7): [True: 327k, False: 156k] ------------------ 62| 327k| ap->a.a_uint = va_arg (args, unsigned int); 63| 327k| break; 64| 0| case TYPE_LONGINT: ------------------ | Branch (64:7): [True: 0, False: 484k] ------------------ 65| 0| ap->a.a_longint = va_arg (args, long int); 66| 0| break; 67| 9.27k| case TYPE_ULONGINT: ------------------ | Branch (67:7): [True: 9.27k, False: 474k] ------------------ 68| 9.27k| ap->a.a_ulongint = va_arg (args, unsigned long int); 69| 9.27k| break; 70| 0|#if HAVE_LONG_LONG 71| 0| case TYPE_LONGLONGINT: ------------------ | Branch (71:7): [True: 0, False: 484k] ------------------ 72| 0| ap->a.a_longlongint = va_arg (args, long long int); 73| 0| break; 74| 0| case TYPE_ULONGLONGINT: ------------------ | Branch (74:7): [True: 0, False: 484k] ------------------ 75| 0| ap->a.a_ulonglongint = va_arg (args, unsigned long long int); 76| 0| break; 77| 0|#endif 78| 0| case TYPE_DOUBLE: ------------------ | Branch (78:7): [True: 0, False: 484k] ------------------ 79| 0| ap->a.a_double = va_arg (args, double); 80| 0| break; 81| 0| case TYPE_LONGDOUBLE: ------------------ | Branch (81:7): [True: 0, False: 484k] ------------------ 82| 0| ap->a.a_longdouble = va_arg (args, long double); 83| 0| break; 84| 0| case TYPE_CHAR: ------------------ | Branch (84:7): [True: 0, False: 484k] ------------------ 85| 0| ap->a.a_char = va_arg (args, int); 86| 0| break; 87| 0|#if HAVE_WINT_T 88| 0| case TYPE_WIDE_CHAR: ------------------ | Branch (88:7): [True: 0, False: 484k] ------------------ 89| | /* Although ISO C 99 7.24.1.(2) says that wint_t is "unchanged by 90| | default argument promotions", this is not the case in mingw32, 91| | where wint_t is 'unsigned short'. */ 92| 0| ap->a.a_wide_char = 93| 0| (sizeof (wint_t) < sizeof (int) ------------------ | Branch (93:12): [Folded, False: 0] ------------------ 94| 0| ? (wint_t) va_arg (args, int) 95| 0| : va_arg (args, wint_t)); 96| 0| break; 97| 0|#endif 98| 146k| case TYPE_STRING: ------------------ | Branch (98:7): [True: 146k, False: 337k] ------------------ 99| 146k| ap->a.a_string = va_arg (args, const char *); 100| | /* A null pointer is an invalid argument for "%s", but in practice 101| | it occurs quite frequently in printf statements that produce 102| | debug output. Use a fallback in this case. */ 103| 146k| if (ap->a.a_string == NULL) ------------------ | Branch (103:13): [True: 4.81k, False: 142k] ------------------ 104| 4.81k| ap->a.a_string = "(NULL)"; 105| 146k| break; 106| 0|#if HAVE_WCHAR_T 107| 0| case TYPE_WIDE_STRING: ------------------ | Branch (107:7): [True: 0, False: 484k] ------------------ 108| 0| ap->a.a_wide_string = va_arg (args, const wchar_t *); 109| | /* A null pointer is an invalid argument for "%ls", but in practice 110| | it occurs quite frequently in printf statements that produce 111| | debug output. Use a fallback in this case. */ 112| 0| if (ap->a.a_wide_string == NULL) ------------------ | Branch (112:13): [True: 0, False: 0] ------------------ 113| 0| { 114| 0| static const wchar_t wide_null_string[] = 115| 0| { 116| 0| (wchar_t)'(', 117| 0| (wchar_t)'N', (wchar_t)'U', (wchar_t)'L', (wchar_t)'L', 118| 0| (wchar_t)')', 119| 0| (wchar_t)0 120| 0| }; 121| 0| ap->a.a_wide_string = wide_null_string; 122| 0| } 123| 0| break; 124| 0|#endif 125| 0| case TYPE_POINTER: ------------------ | Branch (125:7): [True: 0, False: 484k] ------------------ 126| 0| ap->a.a_pointer = va_arg (args, void *); 127| 0| break; 128| 0| case TYPE_COUNT_SCHAR_POINTER: ------------------ | Branch (128:7): [True: 0, False: 484k] ------------------ 129| 0| ap->a.a_count_schar_pointer = va_arg (args, signed char *); 130| 0| break; 131| 0| case TYPE_COUNT_SHORT_POINTER: ------------------ | Branch (131:7): [True: 0, False: 484k] ------------------ 132| 0| ap->a.a_count_short_pointer = va_arg (args, short *); 133| 0| break; 134| 0| case TYPE_COUNT_INT_POINTER: ------------------ | Branch (134:7): [True: 0, False: 484k] ------------------ 135| 0| ap->a.a_count_int_pointer = va_arg (args, int *); 136| 0| break; 137| 0| case TYPE_COUNT_LONGINT_POINTER: ------------------ | Branch (137:7): [True: 0, False: 484k] ------------------ 138| 0| ap->a.a_count_longint_pointer = va_arg (args, long int *); 139| 0| break; 140| 0|#if HAVE_LONG_LONG 141| 0| case TYPE_COUNT_LONGLONGINT_POINTER: ------------------ | Branch (141:7): [True: 0, False: 484k] ------------------ 142| 0| ap->a.a_count_longlongint_pointer = va_arg (args, long long int *); 143| 0| break; 144| 0|#endif 145| |#if ENABLE_UNISTDIO 146| | /* The unistdio extensions. */ 147| | case TYPE_U8_STRING: 148| | ap->a.a_u8_string = va_arg (args, const uint8_t *); 149| | /* A null pointer is an invalid argument for "%U", but in practice 150| | it occurs quite frequently in printf statements that produce 151| | debug output. Use a fallback in this case. */ 152| | if (ap->a.a_u8_string == NULL) 153| | { 154| | static const uint8_t u8_null_string[] = 155| | { '(', 'N', 'U', 'L', 'L', ')', 0 }; 156| | ap->a.a_u8_string = u8_null_string; 157| | } 158| | break; 159| | case TYPE_U16_STRING: 160| | ap->a.a_u16_string = va_arg (args, const uint16_t *); 161| | /* A null pointer is an invalid argument for "%lU", but in practice 162| | it occurs quite frequently in printf statements that produce 163| | debug output. Use a fallback in this case. */ 164| | if (ap->a.a_u16_string == NULL) 165| | { 166| | static const uint16_t u16_null_string[] = 167| | { '(', 'N', 'U', 'L', 'L', ')', 0 }; 168| | ap->a.a_u16_string = u16_null_string; 169| | } 170| | break; 171| | case TYPE_U32_STRING: 172| | ap->a.a_u32_string = va_arg (args, const uint32_t *); 173| | /* A null pointer is an invalid argument for "%llU", but in practice 174| | it occurs quite frequently in printf statements that produce 175| | debug output. Use a fallback in this case. */ 176| | if (ap->a.a_u32_string == NULL) 177| | { 178| | static const uint32_t u32_null_string[] = 179| | { '(', 'N', 'U', 'L', 'L', ')', 0 }; 180| | ap->a.a_u32_string = u32_null_string; 181| | } 182| | break; 183| |#endif 184| 0| default: ------------------ | Branch (184:7): [True: 0, False: 484k] ------------------ 185| | /* Unknown type. */ 186| 0| return -1; 187| 484k| } 188| 257k| return 0; 189| 257k|} _g_gnulib_printf_parse: 86| 257k|{ 87| 257k| const CHAR_T *cp = format; /* pointer into format */ 88| 257k| size_t arg_posn = 0; /* number of regular arguments consumed */ 89| 257k| size_t d_allocated; /* allocated elements of d->dir */ 90| 257k| size_t a_allocated; /* allocated elements of a->arg */ 91| 257k| size_t max_width_length = 0; 92| 257k| size_t max_precision_length = 0; 93| | 94| 257k| d->count = 0; 95| 257k| d_allocated = N_DIRECT_ALLOC_DIRECTIVES; ------------------ | | 50| 257k|#define N_DIRECT_ALLOC_DIRECTIVES 7 ------------------ 96| 257k| d->dir = d->direct_alloc_dir; 97| | 98| 257k| a->count = 0; 99| 257k| a_allocated = N_DIRECT_ALLOC_ARGUMENTS; ------------------ | | 139| 257k|#define N_DIRECT_ALLOC_ARGUMENTS 7 ------------------ 100| 257k| a->arg = a->direct_alloc_arg; 101| | 102| 257k|#define REGISTER_ARG(_index_,_type_) \ 103| 257k| { \ 104| 257k| size_t n = (_index_); \ 105| 257k| if (n >= a_allocated) \ 106| 257k| { \ 107| 257k| size_t memory_size; \ 108| 257k| argument *memory; \ 109| 257k| \ 110| 257k| a_allocated = xtimes (a_allocated, 2); \ 111| 257k| if (a_allocated <= n) \ 112| 257k| a_allocated = xsum (n, 1); \ 113| 257k| memory_size = xtimes (a_allocated, sizeof (argument)); \ 114| 257k| if (size_overflow_p (memory_size)) \ 115| | /* Overflow, would lead to out of memory. */ \ 116| 257k| goto out_of_memory; \ 117| 257k| memory = (argument *) (a->arg != a->direct_alloc_arg \ 118| 257k| ? realloc (a->arg, memory_size) \ 119| 257k| : malloc (memory_size)); \ 120| 257k| if (memory == NULL) \ 121| | /* Out of memory. */ \ 122| 257k| goto out_of_memory; \ 123| 257k| if (a->arg == a->direct_alloc_arg) \ 124| 257k| memcpy (memory, a->arg, a->count * sizeof (argument)); \ 125| 257k| a->arg = memory; \ 126| 257k| } \ 127| 257k| while (a->count <= n) \ 128| 257k| a->arg[a->count++].type = TYPE_NONE; \ 129| 257k| if (a->arg[n].type == TYPE_NONE) \ 130| 257k| a->arg[n].type = (_type_); \ 131| 257k| else if (a->arg[n].type != (_type_)) \ 132| | /* Ambiguous type for positional argument. */ \ 133| 257k| goto error; \ 134| 257k| } 135| | 136| 3.92M| while (*cp != '\0') ------------------ | Branch (136:10): [True: 3.66M, False: 257k] ------------------ 137| 3.66M| { 138| 3.66M| CHAR_T c = *cp++; ------------------ | | 44| 3.66M|# define CHAR_T char ------------------ 139| 3.66M| if (c == '%') ------------------ | Branch (139:11): [True: 484k, False: 3.18M] ------------------ 140| 484k| { 141| 484k| size_t arg_index = ARG_NONE; ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ 142| 484k| DIRECTIVE *dp = &d->dir[d->count]; /* pointer to next directive */ ------------------ | | 45| 484k|# define DIRECTIVE char_directive ------------------ 143| | 144| | /* Initialize the next directive. */ 145| 484k| dp->dir_start = cp - 1; 146| 484k| dp->flags = 0; 147| 484k| dp->width_start = NULL; 148| 484k| dp->width_end = NULL; 149| 484k| dp->width_arg_index = ARG_NONE; ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ 150| 484k| dp->precision_start = NULL; 151| 484k| dp->precision_end = NULL; 152| 484k| dp->precision_arg_index = ARG_NONE; ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ 153| 484k| dp->arg_index = ARG_NONE; ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ 154| | 155| | /* Test for positional argument. */ 156| 484k| if (*cp >= '0' && *cp <= '9') ------------------ | Branch (156:15): [True: 484k, False: 0] | Branch (156:29): [True: 3.39k, False: 480k] ------------------ 157| 3.39k| { 158| 3.39k| const CHAR_T *np; 159| | 160| 10.1k| for (np = cp; *np >= '0' && *np <= '9'; np++) ------------------ | Branch (160:29): [True: 10.1k, False: 0] | Branch (160:43): [True: 6.78k, False: 3.39k] ------------------ 161| 6.78k| ; 162| 3.39k| if (*np == '$') ------------------ | Branch (162:19): [True: 0, False: 3.39k] ------------------ 163| 0| { 164| 0| size_t n = 0; 165| | 166| 0| for (np = cp; *np >= '0' && *np <= '9'; np++) ------------------ | Branch (166:33): [True: 0, False: 0] | Branch (166:47): [True: 0, False: 0] ------------------ 167| 0| n = xsum (xtimes (n, 10), *np - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 168| 0| if (n == 0) ------------------ | Branch (168:23): [True: 0, False: 0] ------------------ 169| | /* Positional argument 0. */ 170| 0| goto error; 171| 0| if (size_overflow_p (n)) ------------------ | | 112| 0| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 0] | | ------------------ ------------------ 172| | /* n too large, would lead to out of memory later. */ 173| 0| goto error; 174| 0| arg_index = n - 1; 175| 0| cp = np + 1; 176| 0| } 177| 3.39k| } 178| | 179| | /* Read the flags. */ 180| 484k| for (;;) 181| 487k| { 182| 487k| if (*cp == '\'') ------------------ | Branch (182:19): [True: 0, False: 487k] ------------------ 183| 0| { 184| 0| dp->flags |= FLAG_GROUP; ------------------ | | 33| 0|#define FLAG_GROUP 1 /* ' flag */ ------------------ 185| 0| cp++; 186| 0| } 187| 487k| else if (*cp == '-') ------------------ | Branch (187:24): [True: 0, False: 487k] ------------------ 188| 0| { 189| 0| dp->flags |= FLAG_LEFT; ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ 190| 0| cp++; 191| 0| } 192| 487k| else if (*cp == '+') ------------------ | Branch (192:24): [True: 0, False: 487k] ------------------ 193| 0| { 194| 0| dp->flags |= FLAG_SHOWSIGN; ------------------ | | 35| 0|#define FLAG_SHOWSIGN 4 /* + flag */ ------------------ 195| 0| cp++; 196| 0| } 197| 487k| else if (*cp == ' ') ------------------ | Branch (197:24): [True: 0, False: 487k] ------------------ 198| 0| { 199| 0| dp->flags |= FLAG_SPACE; ------------------ | | 36| 0|#define FLAG_SPACE 8 /* space flag */ ------------------ 200| 0| cp++; 201| 0| } 202| 487k| else if (*cp == '#') ------------------ | Branch (202:24): [True: 0, False: 487k] ------------------ 203| 0| { 204| 0| dp->flags |= FLAG_ALT; ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ 205| 0| cp++; 206| 0| } 207| 487k| else if (*cp == '0') ------------------ | Branch (207:24): [True: 3.39k, False: 484k] ------------------ 208| 3.39k| { 209| 3.39k| dp->flags |= FLAG_ZERO; ------------------ | | 38| 3.39k|#define FLAG_ZERO 32 ------------------ 210| 3.39k| cp++; 211| 3.39k| } 212| 484k|#if __GLIBC__ >= 2 && !defined __UCLIBC__ 213| 484k| else if (*cp == 'I') ------------------ | Branch (213:24): [True: 0, False: 484k] ------------------ 214| 0| { 215| 0| dp->flags |= FLAG_LOCALIZED; ------------------ | | 40| 0|# define FLAG_LOCALIZED 64 /* I flag, uses localized digits */ ------------------ 216| 0| cp++; 217| 0| } 218| 484k|#endif 219| 484k| else 220| 484k| break; 221| 487k| } 222| | 223| | /* Parse the field width. */ 224| 484k| if (*cp == '*') ------------------ | Branch (224:15): [True: 0, False: 484k] ------------------ 225| 0| { 226| 0| dp->width_start = cp; 227| 0| cp++; 228| 0| dp->width_end = cp; 229| 0| if (max_width_length < 1) ------------------ | Branch (229:19): [True: 0, False: 0] ------------------ 230| 0| max_width_length = 1; 231| | 232| | /* Test for positional argument. */ 233| 0| if (*cp >= '0' && *cp <= '9') ------------------ | Branch (233:19): [True: 0, False: 0] | Branch (233:33): [True: 0, False: 0] ------------------ 234| 0| { 235| 0| const CHAR_T *np; 236| | 237| 0| for (np = cp; *np >= '0' && *np <= '9'; np++) ------------------ | Branch (237:33): [True: 0, False: 0] | Branch (237:47): [True: 0, False: 0] ------------------ 238| 0| ; 239| 0| if (*np == '$') ------------------ | Branch (239:23): [True: 0, False: 0] ------------------ 240| 0| { 241| 0| size_t n = 0; 242| | 243| 0| for (np = cp; *np >= '0' && *np <= '9'; np++) ------------------ | Branch (243:37): [True: 0, False: 0] | Branch (243:51): [True: 0, False: 0] ------------------ 244| 0| n = xsum (xtimes (n, 10), *np - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 245| 0| if (n == 0) ------------------ | Branch (245:27): [True: 0, False: 0] ------------------ 246| | /* Positional argument 0. */ 247| 0| goto error; 248| 0| if (size_overflow_p (n)) ------------------ | | 112| 0| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 0] | | ------------------ ------------------ 249| | /* n too large, would lead to out of memory later. */ 250| 0| goto error; 251| 0| dp->width_arg_index = n - 1; 252| 0| cp = np + 1; 253| 0| } 254| 0| } 255| 0| if (dp->width_arg_index == ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (255:19): [True: 0, False: 0] ------------------ 256| 0| { 257| 0| dp->width_arg_index = arg_posn++; 258| 0| if (dp->width_arg_index == ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (258:23): [True: 0, False: 0] ------------------ 259| | /* arg_posn wrapped around. */ 260| 0| goto error; 261| 0| } 262| 0| REGISTER_ARG (dp->width_arg_index, TYPE_INT); ------------------ | | 103| 0| { \ | | 104| 0| size_t n = (_index_); \ | | 105| 0| if (n >= a_allocated) \ | | ------------------ | | | Branch (105:9): [True: 0, False: 0] | | ------------------ | | 106| 0| { \ | | 107| 0| size_t memory_size; \ | | 108| 0| argument *memory; \ | | 109| 0| \ | | 110| 0| a_allocated = xtimes (a_allocated, 2); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 111| 0| if (a_allocated <= n) \ | | ------------------ | | | Branch (111:13): [True: 0, False: 0] | | ------------------ | | 112| 0| a_allocated = xsum (n, 1); \ | | 113| 0| memory_size = xtimes (a_allocated, sizeof (argument)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 114| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 115| 0| /* Overflow, would lead to out of memory. */ \ | | 116| 0| goto out_of_memory; \ | | 117| 0| memory = (argument *) (a->arg != a->direct_alloc_arg \ | | ------------------ | | | Branch (117:32): [True: 0, False: 0] | | ------------------ | | 118| 0| ? realloc (a->arg, memory_size) \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 119| 0| : malloc (memory_size)); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 120| 0| if (memory == NULL) \ | | ------------------ | | | Branch (120:13): [True: 0, False: 0] | | ------------------ | | 121| 0| /* Out of memory. */ \ | | 122| 0| goto out_of_memory; \ | | 123| 0| if (a->arg == a->direct_alloc_arg) \ | | ------------------ | | | Branch (123:13): [True: 0, False: 0] | | ------------------ | | 124| 0| memcpy (memory, a->arg, a->count * sizeof (argument)); \ | | 125| 0| a->arg = memory; \ | | 126| 0| } \ | | 127| 0| while (a->count <= n) \ | | ------------------ | | | Branch (127:12): [True: 0, False: 0] | | ------------------ | | 128| 0| a->arg[a->count++].type = TYPE_NONE; \ | | 129| 0| if (a->arg[n].type == TYPE_NONE) \ | | ------------------ | | | Branch (129:9): [True: 0, False: 0] | | ------------------ | | 130| 0| a->arg[n].type = (_type_); \ | | 131| 0| else if (a->arg[n].type != (_type_)) \ | | ------------------ | | | Branch (131:14): [True: 0, False: 0] | | ------------------ | | 132| 0| /* Ambiguous type for positional argument. */ \ | | 133| 0| goto error; \ | | 134| 0| } ------------------ 263| 0| } 264| 484k| else if (*cp >= '0' && *cp <= '9') ------------------ | Branch (264:20): [True: 484k, False: 0] | Branch (264:34): [True: 3.39k, False: 480k] ------------------ 265| 3.39k| { 266| 3.39k| size_t width_length; 267| | 268| 3.39k| dp->width_start = cp; 269| 6.78k| for (; *cp >= '0' && *cp <= '9'; cp++) ------------------ | Branch (269:22): [True: 6.78k, False: 0] | Branch (269:36): [True: 3.39k, False: 3.39k] ------------------ 270| 3.39k| ; 271| 3.39k| dp->width_end = cp; 272| 3.39k| width_length = dp->width_end - dp->width_start; 273| 3.39k| if (max_width_length < width_length) ------------------ | Branch (273:19): [True: 339, False: 3.05k] ------------------ 274| 339| max_width_length = width_length; 275| 3.39k| } 276| | 277| | /* Parse the precision. */ 278| 484k| if (*cp == '.') ------------------ | Branch (278:15): [True: 0, False: 484k] ------------------ 279| 0| { 280| 0| cp++; 281| 0| if (*cp == '*') ------------------ | Branch (281:19): [True: 0, False: 0] ------------------ 282| 0| { 283| 0| dp->precision_start = cp - 1; 284| 0| cp++; 285| 0| dp->precision_end = cp; 286| 0| if (max_precision_length < 2) ------------------ | Branch (286:23): [True: 0, False: 0] ------------------ 287| 0| max_precision_length = 2; 288| | 289| | /* Test for positional argument. */ 290| 0| if (*cp >= '0' && *cp <= '9') ------------------ | Branch (290:23): [True: 0, False: 0] | Branch (290:37): [True: 0, False: 0] ------------------ 291| 0| { 292| 0| const CHAR_T *np; 293| | 294| 0| for (np = cp; *np >= '0' && *np <= '9'; np++) ------------------ | Branch (294:37): [True: 0, False: 0] | Branch (294:51): [True: 0, False: 0] ------------------ 295| 0| ; 296| 0| if (*np == '$') ------------------ | Branch (296:27): [True: 0, False: 0] ------------------ 297| 0| { 298| 0| size_t n = 0; 299| | 300| 0| for (np = cp; *np >= '0' && *np <= '9'; np++) ------------------ | Branch (300:41): [True: 0, False: 0] | Branch (300:55): [True: 0, False: 0] ------------------ 301| 0| n = xsum (xtimes (n, 10), *np - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 302| 0| if (n == 0) ------------------ | Branch (302:31): [True: 0, False: 0] ------------------ 303| | /* Positional argument 0. */ 304| 0| goto error; 305| 0| if (size_overflow_p (n)) ------------------ | | 112| 0| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 0] | | ------------------ ------------------ 306| | /* n too large, would lead to out of memory 307| | later. */ 308| 0| goto error; 309| 0| dp->precision_arg_index = n - 1; 310| 0| cp = np + 1; 311| 0| } 312| 0| } 313| 0| if (dp->precision_arg_index == ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (313:23): [True: 0, False: 0] ------------------ 314| 0| { 315| 0| dp->precision_arg_index = arg_posn++; 316| 0| if (dp->precision_arg_index == ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (316:27): [True: 0, False: 0] ------------------ 317| | /* arg_posn wrapped around. */ 318| 0| goto error; 319| 0| } 320| 0| REGISTER_ARG (dp->precision_arg_index, TYPE_INT); ------------------ | | 103| 0| { \ | | 104| 0| size_t n = (_index_); \ | | 105| 0| if (n >= a_allocated) \ | | ------------------ | | | Branch (105:9): [True: 0, False: 0] | | ------------------ | | 106| 0| { \ | | 107| 0| size_t memory_size; \ | | 108| 0| argument *memory; \ | | 109| 0| \ | | 110| 0| a_allocated = xtimes (a_allocated, 2); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 111| 0| if (a_allocated <= n) \ | | ------------------ | | | Branch (111:13): [True: 0, False: 0] | | ------------------ | | 112| 0| a_allocated = xsum (n, 1); \ | | 113| 0| memory_size = xtimes (a_allocated, sizeof (argument)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 114| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 115| 0| /* Overflow, would lead to out of memory. */ \ | | 116| 0| goto out_of_memory; \ | | 117| 0| memory = (argument *) (a->arg != a->direct_alloc_arg \ | | ------------------ | | | Branch (117:32): [True: 0, False: 0] | | ------------------ | | 118| 0| ? realloc (a->arg, memory_size) \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 119| 0| : malloc (memory_size)); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 120| 0| if (memory == NULL) \ | | ------------------ | | | Branch (120:13): [True: 0, False: 0] | | ------------------ | | 121| 0| /* Out of memory. */ \ | | 122| 0| goto out_of_memory; \ | | 123| 0| if (a->arg == a->direct_alloc_arg) \ | | ------------------ | | | Branch (123:13): [True: 0, False: 0] | | ------------------ | | 124| 0| memcpy (memory, a->arg, a->count * sizeof (argument)); \ | | 125| 0| a->arg = memory; \ | | 126| 0| } \ | | 127| 0| while (a->count <= n) \ | | ------------------ | | | Branch (127:12): [True: 0, False: 0] | | ------------------ | | 128| 0| a->arg[a->count++].type = TYPE_NONE; \ | | 129| 0| if (a->arg[n].type == TYPE_NONE) \ | | ------------------ | | | Branch (129:9): [True: 0, False: 0] | | ------------------ | | 130| 0| a->arg[n].type = (_type_); \ | | 131| 0| else if (a->arg[n].type != (_type_)) \ | | ------------------ | | | Branch (131:14): [True: 0, False: 0] | | ------------------ | | 132| 0| /* Ambiguous type for positional argument. */ \ | | 133| 0| goto error; \ | | 134| 0| } ------------------ 321| 0| } 322| 0| else 323| 0| { 324| 0| size_t precision_length; 325| | 326| 0| dp->precision_start = cp - 1; 327| 0| for (; *cp >= '0' && *cp <= '9'; cp++) ------------------ | Branch (327:26): [True: 0, False: 0] | Branch (327:40): [True: 0, False: 0] ------------------ 328| 0| ; 329| 0| dp->precision_end = cp; 330| 0| precision_length = dp->precision_end - dp->precision_start; 331| 0| if (max_precision_length < precision_length) ------------------ | Branch (331:23): [True: 0, False: 0] ------------------ 332| 0| max_precision_length = precision_length; 333| 0| } 334| 0| } 335| | 336| 484k| { 337| 484k| arg_type type; 338| | 339| | /* Parse argument type/size specifiers. */ 340| 484k| { 341| 484k| int flags = 0; 342| | 343| 484k| for (;;) 344| 493k| { 345| 493k| if (*cp == 'h') ------------------ | Branch (345:23): [True: 0, False: 493k] ------------------ 346| 0| { 347| 0| flags |= (1 << (flags & 1)); 348| 0| cp++; 349| 0| } 350| 493k| else if (*cp == 'L') ------------------ | Branch (350:28): [True: 0, False: 493k] ------------------ 351| 0| { 352| 0| flags |= 4; 353| 0| cp++; 354| 0| } 355| 493k| else if (*cp == 'l') ------------------ | Branch (355:28): [True: 9.27k, False: 484k] ------------------ 356| 9.27k| { 357| 9.27k| flags += 8; 358| 9.27k| cp++; 359| 9.27k| } 360| 484k| else if (*cp == 'j') ------------------ | Branch (360:28): [True: 0, False: 484k] ------------------ 361| 0| { 362| 0| if (sizeof (intmax_t) > sizeof (long)) ------------------ | Branch (362:27): [Folded, False: 0] ------------------ 363| 0| { 364| | /* intmax_t = long long */ 365| 0| flags += 16; 366| 0| } 367| 0| else if (sizeof (intmax_t) > sizeof (int)) ------------------ | Branch (367:32): [True: 0, Folded] ------------------ 368| 0| { 369| | /* intmax_t = long */ 370| 0| flags += 8; 371| 0| } 372| 0| cp++; 373| 0| } 374| 484k| else if (*cp == 'z' || *cp == 'Z') ------------------ | Branch (374:28): [True: 0, False: 484k] | Branch (374:42): [True: 0, False: 484k] ------------------ 375| 0| { 376| | /* 'z' is standardized in ISO C 99, but glibc uses 'Z' 377| | because the warning facility in gcc-2.95.2 understands 378| | only 'Z' (see gcc-2.95.2/gcc/c-common.c:1784). */ 379| 0| if (sizeof (size_t) > sizeof (long)) ------------------ | Branch (379:27): [Folded, False: 0] ------------------ 380| 0| { 381| | /* size_t = long long */ 382| 0| flags += 16; 383| 0| } 384| 0| else if (sizeof (size_t) > sizeof (int)) ------------------ | Branch (384:32): [True: 0, Folded] ------------------ 385| 0| { 386| | /* size_t = long */ 387| 0| flags += 8; 388| 0| } 389| 0| cp++; 390| 0| } 391| 484k| else if (*cp == 't') ------------------ | Branch (391:28): [True: 0, False: 484k] ------------------ 392| 0| { 393| 0| if (sizeof (ptrdiff_t) > sizeof (long)) ------------------ | Branch (393:27): [Folded, False: 0] ------------------ 394| 0| { 395| | /* ptrdiff_t = long long */ 396| 0| flags += 16; 397| 0| } 398| 0| else if (sizeof (ptrdiff_t) > sizeof (int)) ------------------ | Branch (398:32): [True: 0, Folded] ------------------ 399| 0| { 400| | /* ptrdiff_t = long */ 401| 0| flags += 8; 402| 0| } 403| 0| cp++; 404| 0| } 405| |#if defined __APPLE__ && defined __MACH__ 406| | /* On Mac OS X 10.3, PRIdMAX is defined as "qd". 407| | We cannot change it to "lld" because PRIdMAX must also 408| | be understood by the system's printf routines. */ 409| | else if (*cp == 'q') 410| | { 411| | if (64 / 8 > sizeof (long)) 412| | { 413| | /* int64_t = long long */ 414| | flags += 16; 415| | } 416| | else 417| | { 418| | /* int64_t = long */ 419| | flags += 8; 420| | } 421| | cp++; 422| | } 423| |#endif 424| |#if defined _WIN32 && ! defined __CYGWIN__ 425| | /* On native Windows, PRIdMAX is defined as "I64d". 426| | We cannot change it to "lld" because PRIdMAX must also 427| | be understood by the system's printf routines. */ 428| | else if (*cp == 'I' && cp[1] == '6' && cp[2] == '4') 429| | { 430| | if (64 / 8 > sizeof (long)) 431| | { 432| | /* __int64 = long long */ 433| | flags += 16; 434| | } 435| | else 436| | { 437| | /* __int64 = long */ 438| | flags += 8; 439| | } 440| | cp += 3; 441| | } 442| |#endif 443| 484k| else 444| 484k| break; 445| 493k| } 446| | 447| | /* Read the conversion character. */ 448| 484k| c = *cp++; 449| 484k| switch (c) 450| 484k| { 451| 0| case 'd': case 'i': ------------------ | Branch (451:17): [True: 0, False: 484k] | Branch (451:27): [True: 0, False: 484k] ------------------ 452| 0|#if HAVE_LONG_LONG 453| | /* If 'long long' exists and is larger than 'long': */ 454| 0| if (flags >= 16 || (flags & 4)) ------------------ | Branch (454:23): [True: 0, False: 0] | Branch (454:38): [True: 0, False: 0] ------------------ 455| 0| type = TYPE_LONGLONGINT; 456| 0| else 457| 0|#endif 458| | /* If 'long long' exists and is the same as 'long', we parse 459| | "lld" into TYPE_LONGINT. */ 460| 0| if (flags >= 8) ------------------ | Branch (460:23): [True: 0, False: 0] ------------------ 461| 0| type = TYPE_LONGINT; 462| 0| else if (flags & 2) ------------------ | Branch (462:28): [True: 0, False: 0] ------------------ 463| 0| type = TYPE_SCHAR; 464| 0| else if (flags & 1) ------------------ | Branch (464:28): [True: 0, False: 0] ------------------ 465| 0| type = TYPE_SHORT; 466| 0| else 467| 0| type = TYPE_INT; 468| 0| break; 469| 337k| case 'o': case 'u': case 'x': case 'X': ------------------ | Branch (469:17): [True: 0, False: 484k] | Branch (469:27): [True: 232k, False: 251k] | Branch (469:37): [True: 104k, False: 379k] | Branch (469:47): [True: 0, False: 484k] ------------------ 470| 337k|#if HAVE_LONG_LONG 471| | /* If 'long long' exists and is larger than 'long': */ 472| 337k| if (flags >= 16 || (flags & 4)) ------------------ | Branch (472:23): [True: 0, False: 337k] | Branch (472:38): [True: 0, False: 337k] ------------------ 473| 0| type = TYPE_ULONGLONGINT; 474| 337k| else 475| 337k|#endif 476| | /* If 'unsigned long long' exists and is the same as 477| | 'unsigned long', we parse "llu" into TYPE_ULONGINT. */ 478| 337k| if (flags >= 8) ------------------ | Branch (478:23): [True: 9.27k, False: 327k] ------------------ 479| 9.27k| type = TYPE_ULONGINT; 480| 327k| else if (flags & 2) ------------------ | Branch (480:28): [True: 0, False: 327k] ------------------ 481| 0| type = TYPE_UCHAR; 482| 327k| else if (flags & 1) ------------------ | Branch (482:28): [True: 0, False: 327k] ------------------ 483| 0| type = TYPE_USHORT; 484| 327k| else 485| 327k| type = TYPE_UINT; 486| 337k| break; 487| 0| case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': ------------------ | Branch (487:17): [True: 0, False: 484k] | Branch (487:27): [True: 0, False: 484k] | Branch (487:37): [True: 0, False: 484k] | Branch (487:47): [True: 0, False: 484k] | Branch (487:57): [True: 0, False: 484k] | Branch (487:67): [True: 0, False: 484k] ------------------ 488| 0| case 'a': case 'A': ------------------ | Branch (488:17): [True: 0, False: 484k] | Branch (488:27): [True: 0, False: 484k] ------------------ 489| 0| if (flags >= 16 || (flags & 4)) ------------------ | Branch (489:23): [True: 0, False: 0] | Branch (489:38): [True: 0, False: 0] ------------------ 490| 0| type = TYPE_LONGDOUBLE; 491| 0| else 492| 0| type = TYPE_DOUBLE; 493| 0| break; 494| 0| case 'c': ------------------ | Branch (494:17): [True: 0, False: 484k] ------------------ 495| 0| if (flags >= 8) ------------------ | Branch (495:23): [True: 0, False: 0] ------------------ 496| 0|#if HAVE_WINT_T 497| 0| type = TYPE_WIDE_CHAR; 498| |#else 499| | goto error; 500| |#endif 501| 0| else 502| 0| type = TYPE_CHAR; 503| 0| break; 504| 0|#if HAVE_WINT_T 505| 0| case 'C': ------------------ | Branch (505:17): [True: 0, False: 484k] ------------------ 506| 0| type = TYPE_WIDE_CHAR; 507| 0| c = 'c'; 508| 0| break; 509| 0|#endif 510| 146k| case 's': ------------------ | Branch (510:17): [True: 146k, False: 337k] ------------------ 511| 146k| if (flags >= 8) ------------------ | Branch (511:23): [True: 0, False: 146k] ------------------ 512| 0|#if HAVE_WCHAR_T 513| 0| type = TYPE_WIDE_STRING; 514| |#else 515| | goto error; 516| |#endif 517| 146k| else 518| 146k| type = TYPE_STRING; 519| 146k| break; 520| 0|#if HAVE_WCHAR_T 521| 0| case 'S': ------------------ | Branch (521:17): [True: 0, False: 484k] ------------------ 522| 0| type = TYPE_WIDE_STRING; 523| 0| c = 's'; 524| 0| break; 525| 0|#endif 526| 0| case 'p': ------------------ | Branch (526:17): [True: 0, False: 484k] ------------------ 527| 0| type = TYPE_POINTER; 528| 0| break; 529| 0| case 'n': ------------------ | Branch (529:17): [True: 0, False: 484k] ------------------ 530| 0|#if HAVE_LONG_LONG 531| | /* If 'long long' exists and is larger than 'long': */ 532| 0| if (flags >= 16 || (flags & 4)) ------------------ | Branch (532:23): [True: 0, False: 0] | Branch (532:38): [True: 0, False: 0] ------------------ 533| 0| type = TYPE_COUNT_LONGLONGINT_POINTER; 534| 0| else 535| 0|#endif 536| | /* If 'long long' exists and is the same as 'long', we parse 537| | "lln" into TYPE_COUNT_LONGINT_POINTER. */ 538| 0| if (flags >= 8) ------------------ | Branch (538:23): [True: 0, False: 0] ------------------ 539| 0| type = TYPE_COUNT_LONGINT_POINTER; 540| 0| else if (flags & 2) ------------------ | Branch (540:28): [True: 0, False: 0] ------------------ 541| 0| type = TYPE_COUNT_SCHAR_POINTER; 542| 0| else if (flags & 1) ------------------ | Branch (542:28): [True: 0, False: 0] ------------------ 543| 0| type = TYPE_COUNT_SHORT_POINTER; 544| 0| else 545| 0| type = TYPE_COUNT_INT_POINTER; 546| 0| break; 547| |#if ENABLE_UNISTDIO 548| | /* The unistdio extensions. */ 549| | case 'U': 550| | if (flags >= 16) 551| | type = TYPE_U32_STRING; 552| | else if (flags >= 8) 553| | type = TYPE_U16_STRING; 554| | else 555| | type = TYPE_U8_STRING; 556| | break; 557| |#endif 558| 0| case '%': ------------------ | Branch (558:17): [True: 0, False: 484k] ------------------ 559| 0| type = TYPE_NONE; 560| 0| break; 561| 0| default: ------------------ | Branch (561:17): [True: 0, False: 484k] ------------------ 562| | /* Unknown conversion character. */ 563| 0| goto error; 564| 484k| } 565| 484k| } 566| | 567| 484k| if (type != TYPE_NONE) ------------------ | Branch (567:17): [True: 484k, False: 0] ------------------ 568| 484k| { 569| 484k| dp->arg_index = arg_index; 570| 484k| if (dp->arg_index == ARG_NONE) ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ | Branch (570:21): [True: 484k, False: 0] ------------------ 571| 484k| { 572| 484k| dp->arg_index = arg_posn++; 573| 484k| if (dp->arg_index == ARG_NONE) ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ | Branch (573:25): [True: 0, False: 484k] ------------------ 574| | /* arg_posn wrapped around. */ 575| 0| goto error; 576| 484k| } 577| 968k| REGISTER_ARG (dp->arg_index, type); ------------------ | | 103| 484k| { \ | | 104| 484k| size_t n = (_index_); \ | | 105| 484k| if (n >= a_allocated) \ | | ------------------ | | | Branch (105:9): [True: 339, False: 483k] | | ------------------ | | 106| 484k| { \ | | 107| 339| size_t memory_size; \ | | 108| 339| argument *memory; \ | | 109| 339| \ | | 110| 339| a_allocated = xtimes (a_allocated, 2); \ | | ------------------ | | | | 108| 339| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 339, False: 0] | | | | ------------------ | | ------------------ | | 111| 339| if (a_allocated <= n) \ | | ------------------ | | | Branch (111:13): [True: 0, False: 339] | | ------------------ | | 112| 339| a_allocated = xsum (n, 1); \ | | 113| 339| memory_size = xtimes (a_allocated, sizeof (argument)); \ | | ------------------ | | | | 108| 339| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 339, False: 0] | | | | ------------------ | | ------------------ | | 114| 339| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 339| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 339] | | | | ------------------ | | ------------------ | | 115| 339| /* Overflow, would lead to out of memory. */ \ | | 116| 339| goto out_of_memory; \ | | 117| 339| memory = (argument *) (a->arg != a->direct_alloc_arg \ | | ------------------ | | | Branch (117:32): [True: 0, False: 339] | | ------------------ | | 118| 339| ? realloc (a->arg, memory_size) \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 119| 339| : malloc (memory_size)); \ | | ------------------ | | | | 33| 339|#define malloc g_malloc | | ------------------ | | 120| 339| if (memory == NULL) \ | | ------------------ | | | Branch (120:13): [True: 0, False: 339] | | ------------------ | | 121| 339| /* Out of memory. */ \ | | 122| 339| goto out_of_memory; \ | | 123| 339| if (a->arg == a->direct_alloc_arg) \ | | ------------------ | | | Branch (123:13): [True: 339, False: 0] | | ------------------ | | 124| 339| memcpy (memory, a->arg, a->count * sizeof (argument)); \ | | 125| 339| a->arg = memory; \ | | 126| 339| } \ | | 127| 968k| while (a->count <= n) \ | | ------------------ | | | Branch (127:12): [True: 484k, False: 484k] | | ------------------ | | 128| 484k| a->arg[a->count++].type = TYPE_NONE; \ | | 129| 484k| if (a->arg[n].type == TYPE_NONE) \ | | ------------------ | | | Branch (129:9): [True: 484k, False: 0] | | ------------------ | | 130| 484k| a->arg[n].type = (_type_); \ | | 131| 484k| else if (a->arg[n].type != (_type_)) \ | | ------------------ | | | Branch (131:14): [True: 0, False: 0] | | ------------------ | | 132| 0| /* Ambiguous type for positional argument. */ \ | | 133| 0| goto error; \ | | 134| 484k| } ------------------ 578| 484k| } 579| 484k| dp->conversion = c; 580| 484k| dp->dir_end = cp; 581| 484k| } 582| | 583| 0| d->count++; 584| 484k| if (d->count >= d_allocated) ------------------ | Branch (584:15): [True: 339, False: 483k] ------------------ 585| 339| { 586| 339| size_t memory_size; 587| 339| DIRECTIVE *memory; ------------------ | | 45| 339|# define DIRECTIVE char_directive ------------------ 588| | 589| 339| d_allocated = xtimes (d_allocated, 2); ------------------ | | 108| 339| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 339, False: 0] | | ------------------ ------------------ 590| 339| memory_size = xtimes (d_allocated, sizeof (DIRECTIVE)); ------------------ | | 108| 339| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 339, False: 0] | | ------------------ ------------------ 591| 339| if (size_overflow_p (memory_size)) ------------------ | | 112| 339| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 339|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 339|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 339] | | ------------------ ------------------ 592| | /* Overflow, would lead to out of memory. */ 593| 0| goto out_of_memory; 594| 339| memory = (DIRECTIVE *) (d->dir != d->direct_alloc_dir ------------------ | Branch (594:39): [True: 0, False: 339] ------------------ 595| 339| ? realloc (d->dir, memory_size) ------------------ | | 34| 0|#define realloc g_realloc ------------------ 596| 339| : malloc (memory_size)); ------------------ | | 33| 339|#define malloc g_malloc ------------------ 597| 339| if (memory == NULL) ------------------ | Branch (597:19): [True: 0, False: 339] ------------------ 598| | /* Out of memory. */ 599| 0| goto out_of_memory; 600| 339| if (d->dir == d->direct_alloc_dir) ------------------ | Branch (600:19): [True: 339, False: 0] ------------------ 601| 339| memcpy (memory, d->dir, d->count * sizeof (DIRECTIVE)); 602| 339| d->dir = memory; 603| 339| } 604| 484k| } 605| |#if CHAR_T_ONLY_ASCII 606| | else if (!c_isascii (c)) 607| | { 608| | /* Non-ASCII character. Not supported. */ 609| | goto error; 610| | } 611| |#endif 612| 3.66M| } 613| 257k| d->dir[d->count].dir_start = cp; 614| | 615| 257k| d->max_width_length = max_width_length; 616| 257k| d->max_precision_length = max_precision_length; 617| 257k| return 0; 618| | 619| 0|error: 620| 0| if (a->arg != a->direct_alloc_arg) ------------------ | Branch (620:7): [True: 0, False: 0] ------------------ 621| 0| free (a->arg); ------------------ | | 35| 0|#define free g_free ------------------ 622| 0| if (d->dir != d->direct_alloc_dir) ------------------ | Branch (622:7): [True: 0, False: 0] ------------------ 623| 0| free (d->dir); ------------------ | | 35| 0|#define free g_free ------------------ 624| 0| errno = EINVAL; 625| 0| return -1; 626| | 627| 0|out_of_memory: 628| 0| if (a->arg != a->direct_alloc_arg) ------------------ | Branch (628:7): [True: 0, False: 0] ------------------ 629| 0| free (a->arg); ------------------ | | 35| 0|#define free g_free ------------------ 630| 0| if (d->dir != d->direct_alloc_dir) ------------------ | Branch (630:7): [True: 0, False: 0] ------------------ 631| 0| free (d->dir); ------------------ | | 35| 0|#define free g_free ------------------ 632| 0| errno = ENOMEM; 633| 0| return -1; 634| 257k|} _g_gnulib_vasprintf: 137| 257k|{ 138| 257k| size_t length; 139| | 140| 257k| *result = vasnprintf (NULL, &length, format, args); ------------------ | | 25| 257k|#define vasnprintf _g_gnulib_vasnprintf ------------------ 141| 257k| if (*result == NULL) ------------------ | Branch (141:7): [True: 0, False: 257k] ------------------ 142| 0| return -1; 143| | 144| 257k| return length; 145| 257k|} _g_gnulib_vasnprintf: 1790| 257k|{ 1791| 257k| DIRECTIVES d; ------------------ | | 151| 257k|# define DIRECTIVES char_directives ------------------ 1792| 257k| arguments a; 1793| | 1794| 257k| if (PRINTF_PARSE (format, &d, &a) < 0) ------------------ | | 152| 257k|# define PRINTF_PARSE printf_parse | | ------------------ | | | | 26| 257k|#define printf_parse _g_gnulib_printf_parse | | ------------------ ------------------ | Branch (1794:7): [True: 0, False: 257k] ------------------ 1795| | /* errno is already set. */ 1796| 0| return NULL; 1797| | 1798| 257k|#define CLEANUP() \ 1799| 257k| if (d.dir != d.direct_alloc_dir) \ 1800| 257k| free (d.dir); \ 1801| 257k| if (a.arg != a.direct_alloc_arg) \ 1802| 257k| free (a.arg); 1803| | 1804| 257k| if (PRINTF_FETCHARGS (args, &a) < 0) ------------------ | | 28| 257k|# define PRINTF_FETCHARGS printf_fetchargs | | ------------------ | | | | 27| 257k|#define printf_fetchargs _g_gnulib_printf_fetchargs | | ------------------ ------------------ | Branch (1804:7): [True: 0, False: 257k] ------------------ 1805| 0| { 1806| 0| CLEANUP (); ------------------ | | 1799| 0| if (d.dir != d.direct_alloc_dir) \ | | ------------------ | | | Branch (1799:7): [True: 0, False: 0] | | ------------------ | | 1800| 0| free (d.dir); \ | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ | | 1801| 0| if (a.arg != a.direct_alloc_arg) \ | | ------------------ | | | Branch (1801:7): [True: 0, False: 0] | | ------------------ | | 1802| 0| free (a.arg); | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ ------------------ 1807| 0| errno = EINVAL; 1808| 0| return NULL; 1809| 0| } 1810| | 1811| 257k| { 1812| 257k| size_t buf_neededlength; 1813| 257k| TCHAR_T *buf; ------------------ | | 148| 257k|# define TCHAR_T char ------------------ 1814| 257k| TCHAR_T *buf_malloced; ------------------ | | 148| 257k|# define TCHAR_T char ------------------ 1815| 257k| const FCHAR_T *cp; 1816| 257k| size_t i; 1817| 257k| DIRECTIVE *dp; ------------------ | | 150| 257k|# define DIRECTIVE char_directive ------------------ 1818| | /* Output string accumulator. */ 1819| 257k| DCHAR_T *result; ------------------ | | 147| 257k|# define DCHAR_T char ------------------ 1820| 257k| size_t allocated; 1821| 257k| size_t length; 1822| | 1823| | /* Allocate a small buffer that will hold a directive passed to 1824| | sprintf or snprintf. */ 1825| 257k| buf_neededlength = 1826| 257k| xsum4 (7, d.max_width_length, d.max_precision_length, 6); 1827| |#if HAVE_ALLOCA 1828| | if (buf_neededlength < 4000 / sizeof (TCHAR_T)) 1829| | { 1830| | buf = (TCHAR_T *) alloca (buf_neededlength * sizeof (TCHAR_T)); 1831| | buf_malloced = NULL; 1832| | } 1833| | else 1834| |#endif 1835| 257k| { 1836| 257k| size_t buf_memsize = xtimes (buf_neededlength, sizeof (TCHAR_T)); ------------------ | | 108| 257k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 257k|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 257k|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 257k|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 257k|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 257k, False: 0] | | ------------------ ------------------ 1837| 257k| if (size_overflow_p (buf_memsize)) ------------------ | | 112| 257k| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 257k|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 257k|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 257k] | | ------------------ ------------------ 1838| 0| goto out_of_memory_1; 1839| 257k| buf = (TCHAR_T *) malloc (buf_memsize); ------------------ | | 33| 257k|#define malloc g_malloc ------------------ 1840| 257k| if (buf == NULL) ------------------ | Branch (1840:13): [True: 0, False: 257k] ------------------ 1841| 0| goto out_of_memory_1; 1842| 257k| buf_malloced = buf; 1843| 257k| } 1844| | 1845| 257k| if (resultbuf != NULL) ------------------ | Branch (1845:9): [True: 0, False: 257k] ------------------ 1846| 0| { 1847| 0| result = resultbuf; 1848| 0| allocated = *lengthp; 1849| 0| } 1850| 257k| else 1851| 257k| { 1852| 257k| result = NULL; 1853| 257k| allocated = 0; 1854| 257k| } 1855| 257k| length = 0; 1856| | /* Invariants: 1857| | result is either == resultbuf or == NULL or malloc-allocated. 1858| | If length > 0, then result != NULL. */ 1859| | 1860| | /* Ensures that allocated >= needed. Aborts through a jump to 1861| | out_of_memory if needed is SIZE_MAX or otherwise too big. */ 1862| 257k|#define ENSURE_ALLOCATION(needed) \ 1863| 257k| if ((needed) > allocated) \ 1864| 257k| { \ 1865| 257k| size_t memory_size; \ 1866| 257k| DCHAR_T *memory; \ 1867| 257k| \ 1868| 257k| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ 1869| 257k| if ((needed) > allocated) \ 1870| 257k| allocated = (needed); \ 1871| 257k| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ 1872| 257k| if (size_overflow_p (memory_size)) \ 1873| 257k| goto out_of_memory; \ 1874| 257k| if (result == resultbuf || result == NULL) \ 1875| 257k| memory = (DCHAR_T *) malloc (memory_size); \ 1876| 257k| else \ 1877| 257k| memory = (DCHAR_T *) realloc (result, memory_size); \ 1878| 257k| if (memory == NULL) \ 1879| 257k| goto out_of_memory; \ 1880| 257k| if (result == resultbuf && length > 0) \ 1881| 257k| DCHAR_CPY (memory, result, length); \ 1882| 257k| result = memory; \ 1883| 257k| } 1884| | 1885| 484k| for (cp = format, i = 0, dp = &d.dir[0]; ; cp = dp->dir_end, i++, dp++) 1886| 741k| { 1887| 741k| if (cp != dp->dir_start) ------------------ | Branch (1887:13): [True: 506k, False: 235k] ------------------ 1888| 506k| { 1889| 506k| size_t n = dp->dir_start - cp; 1890| 506k| size_t augmented_length = xsum (length, n); 1891| | 1892| 506k| ENSURE_ALLOCATION (augmented_length); ------------------ | | 1863| 506k| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 300k, False: 205k] | | ------------------ | | 1864| 506k| { \ | | 1865| 300k| size_t memory_size; \ | | 1866| 300k| DCHAR_T *memory; \ | | ------------------ | | | | 147| 300k|# define DCHAR_T char | | ------------------ | | 1867| 300k| \ | | 1868| 300k| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 43.4k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 43.4k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 43.4k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 43.4k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 43.4k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 43.4k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 43.4k, False: 257k] | | ------------------ | | 1869| 300k| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 24.5k, False: 275k] | | ------------------ | | 1870| 300k| allocated = (needed); \ | | 1871| 300k| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 300k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 300k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 300k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 300k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 300k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 300k, False: 0] | | | | ------------------ | | ------------------ | | 1872| 300k| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 300k| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 300k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 300k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 300k] | | | | ------------------ | | ------------------ | | 1873| 300k| goto out_of_memory; \ | | 1874| 300k| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 257k, False: 43.4k] | | | Branch (1874:36): [True: 0, False: 43.4k] | | ------------------ | | 1875| 300k| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 257k|#define malloc g_malloc | | ------------------ | | 1876| 300k| else \ | | 1877| 300k| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 43.4k|#define realloc g_realloc | | ------------------ | | 1878| 300k| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 300k] | | ------------------ | | 1879| 300k| goto out_of_memory; \ | | 1880| 300k| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 257k, False: 43.4k] | | | Branch (1880:36): [True: 0, False: 257k] | | ------------------ | | 1881| 300k| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 300k| result = memory; \ | | 1883| 300k| } ------------------ 1893| | /* This copies a piece of FCHAR_T[] into a DCHAR_T[]. Here we 1894| | need that the format string contains only ASCII characters 1895| | if FCHAR_T and DCHAR_T are not the same type. */ 1896| 506k| if (sizeof (FCHAR_T) == sizeof (DCHAR_T)) ------------------ | Branch (1896:17): [True: 506k, Folded] ------------------ 1897| 506k| { 1898| 506k| DCHAR_CPY (result + length, (const DCHAR_T *) cp, n); ------------------ | | 153| 506k|# define DCHAR_CPY memcpy ------------------ 1899| 506k| length = augmented_length; 1900| 506k| } 1901| 0| else 1902| 0| { 1903| 0| do 1904| 0| result[length++] = *cp++; 1905| 0| while (--n > 0); ------------------ | Branch (1905:24): [True: 0, False: 0] ------------------ 1906| 0| } 1907| 506k| } 1908| 741k| if (i == d.count) ------------------ | Branch (1908:13): [True: 257k, False: 484k] ------------------ 1909| 257k| break; 1910| | 1911| | /* Execute a single directive. */ 1912| 484k| if (dp->conversion == '%') ------------------ | Branch (1912:13): [True: 0, False: 484k] ------------------ 1913| 0| { 1914| 0| size_t augmented_length; 1915| | 1916| 0| if (!(dp->arg_index == ARG_NONE)) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (1916:17): [True: 0, False: 0] ------------------ 1917| 0| abort (); 1918| 0| augmented_length = xsum (length, 1); 1919| 0| ENSURE_ALLOCATION (augmented_length); ------------------ | | 1863| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 0, False: 0] | | ------------------ | | 1864| 0| { \ | | 1865| 0| size_t memory_size; \ | | 1866| 0| DCHAR_T *memory; \ | | ------------------ | | | | 147| 0|# define DCHAR_T char | | ------------------ | | 1867| 0| \ | | 1868| 0| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 0, False: 0] | | ------------------ | | 1869| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 0] | | ------------------ | | 1870| 0| allocated = (needed); \ | | 1871| 0| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1872| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1873| 0| goto out_of_memory; \ | | 1874| 0| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 0] | | | Branch (1874:36): [True: 0, False: 0] | | ------------------ | | 1875| 0| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 0| else \ | | 1877| 0| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 1878| 0| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 0] | | ------------------ | | 1879| 0| goto out_of_memory; \ | | 1880| 0| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 0] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 0| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 0| result = memory; \ | | 1883| 0| } ------------------ 1920| 0| result[length] = '%'; 1921| 0| length = augmented_length; 1922| 0| } 1923| 484k| else 1924| 484k| { 1925| 484k| if (!(dp->arg_index != ARG_NONE)) ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ | Branch (1925:17): [True: 0, False: 484k] ------------------ 1926| 0| abort (); 1927| | 1928| 484k| if (dp->conversion == 'n') ------------------ | Branch (1928:17): [True: 0, False: 484k] ------------------ 1929| 0| { 1930| 0| switch (a.arg[dp->arg_index].type) 1931| 0| { 1932| 0| case TYPE_COUNT_SCHAR_POINTER: ------------------ | Branch (1932:19): [True: 0, False: 0] ------------------ 1933| 0| *a.arg[dp->arg_index].a.a_count_schar_pointer = length; 1934| 0| break; 1935| 0| case TYPE_COUNT_SHORT_POINTER: ------------------ | Branch (1935:19): [True: 0, False: 0] ------------------ 1936| 0| *a.arg[dp->arg_index].a.a_count_short_pointer = length; 1937| 0| break; 1938| 0| case TYPE_COUNT_INT_POINTER: ------------------ | Branch (1938:19): [True: 0, False: 0] ------------------ 1939| 0| *a.arg[dp->arg_index].a.a_count_int_pointer = length; 1940| 0| break; 1941| 0| case TYPE_COUNT_LONGINT_POINTER: ------------------ | Branch (1941:19): [True: 0, False: 0] ------------------ 1942| 0| *a.arg[dp->arg_index].a.a_count_longint_pointer = length; 1943| 0| break; 1944| 0|#if HAVE_LONG_LONG 1945| 0| case TYPE_COUNT_LONGLONGINT_POINTER: ------------------ | Branch (1945:19): [True: 0, False: 0] ------------------ 1946| 0| *a.arg[dp->arg_index].a.a_count_longlongint_pointer = length; 1947| 0| break; 1948| 0|#endif 1949| 0| default: ------------------ | Branch (1949:19): [True: 0, False: 0] ------------------ 1950| 0| abort (); 1951| 0| } 1952| 0| } 1953| |#if ENABLE_UNISTDIO 1954| | /* The unistdio extensions. */ 1955| | else if (dp->conversion == 'U') 1956| | { 1957| | arg_type type = a.arg[dp->arg_index].type; 1958| | int flags = dp->flags; 1959| | int has_width; 1960| | size_t width; 1961| | int has_precision; 1962| | size_t precision; 1963| | 1964| | has_width = 0; 1965| | width = 0; 1966| | if (dp->width_start != dp->width_end) 1967| | { 1968| | if (dp->width_arg_index != ARG_NONE) 1969| | { 1970| | int arg; 1971| | 1972| | if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) 1973| | abort (); 1974| | arg = a.arg[dp->width_arg_index].a.a_int; 1975| | width = arg; 1976| | if (arg < 0) 1977| | { 1978| | /* "A negative field width is taken as a '-' flag 1979| | followed by a positive field width." */ 1980| | flags |= FLAG_LEFT; 1981| | width = -width; 1982| | } 1983| | } 1984| | else 1985| | { 1986| | const FCHAR_T *digitp = dp->width_start; 1987| | 1988| | do 1989| | width = xsum (xtimes (width, 10), *digitp++ - '0'); 1990| | while (digitp != dp->width_end); 1991| | } 1992| | has_width = 1; 1993| | } 1994| | 1995| | has_precision = 0; 1996| | precision = 0; 1997| | if (dp->precision_start != dp->precision_end) 1998| | { 1999| | if (dp->precision_arg_index != ARG_NONE) 2000| | { 2001| | int arg; 2002| | 2003| | if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) 2004| | abort (); 2005| | arg = a.arg[dp->precision_arg_index].a.a_int; 2006| | /* "A negative precision is taken as if the precision 2007| | were omitted." */ 2008| | if (arg >= 0) 2009| | { 2010| | precision = arg; 2011| | has_precision = 1; 2012| | } 2013| | } 2014| | else 2015| | { 2016| | const FCHAR_T *digitp = dp->precision_start + 1; 2017| | 2018| | precision = 0; 2019| | while (digitp != dp->precision_end) 2020| | precision = xsum (xtimes (precision, 10), *digitp++ - '0'); 2021| | has_precision = 1; 2022| | } 2023| | } 2024| | 2025| | switch (type) 2026| | { 2027| | case TYPE_U8_STRING: 2028| | { 2029| | const uint8_t *arg = a.arg[dp->arg_index].a.a_u8_string; 2030| | const uint8_t *arg_end; 2031| | size_t characters; 2032| | 2033| | if (has_precision) 2034| | { 2035| | /* Use only PRECISION characters, from the left. */ 2036| | arg_end = arg; 2037| | characters = 0; 2038| | for (; precision > 0; precision--) 2039| | { 2040| | int count = u8_strmblen (arg_end); 2041| | if (count == 0) 2042| | break; 2043| | if (count < 0) 2044| | { 2045| | if (!(result == resultbuf || result == NULL)) 2046| | free (result); 2047| | if (buf_malloced != NULL) 2048| | free (buf_malloced); 2049| | CLEANUP (); 2050| | errno = EILSEQ; 2051| | return NULL; 2052| | } 2053| | arg_end += count; 2054| | characters++; 2055| | } 2056| | } 2057| | else if (has_width) 2058| | { 2059| | /* Use the entire string, and count the number of 2060| | characters. */ 2061| | arg_end = arg; 2062| | characters = 0; 2063| | for (;;) 2064| | { 2065| | int count = u8_strmblen (arg_end); 2066| | if (count == 0) 2067| | break; 2068| | if (count < 0) 2069| | { 2070| | if (!(result == resultbuf || result == NULL)) 2071| | free (result); 2072| | if (buf_malloced != NULL) 2073| | free (buf_malloced); 2074| | CLEANUP (); 2075| | errno = EILSEQ; 2076| | return NULL; 2077| | } 2078| | arg_end += count; 2079| | characters++; 2080| | } 2081| | } 2082| | else 2083| | { 2084| | /* Use the entire string. */ 2085| | arg_end = arg + u8_strlen (arg); 2086| | /* The number of characters doesn't matter. */ 2087| | characters = 0; 2088| | } 2089| | 2090| | if (characters < width && !(dp->flags & FLAG_LEFT)) 2091| | { 2092| | size_t n = width - characters; 2093| | ENSURE_ALLOCATION (xsum (length, n)); 2094| | DCHAR_SET (result + length, ' ', n); 2095| | length += n; 2096| | } 2097| | 2098| |# if DCHAR_IS_UINT8_T 2099| | { 2100| | size_t n = arg_end - arg; 2101| | ENSURE_ALLOCATION (xsum (length, n)); 2102| | DCHAR_CPY (result + length, arg, n); 2103| | length += n; 2104| | } 2105| |# else 2106| | { /* Convert. */ 2107| | DCHAR_T *converted = result + length; 2108| | size_t converted_len = allocated - length; 2109| |# if DCHAR_IS_TCHAR 2110| | /* Convert from UTF-8 to locale encoding. */ 2111| | converted = 2112| | u8_conv_to_encoding (locale_charset (), 2113| | iconveh_question_mark, 2114| | arg, arg_end - arg, NULL, 2115| | converted, &converted_len); 2116| |# else 2117| | /* Convert from UTF-8 to UTF-16/UTF-32. */ 2118| | converted = 2119| | U8_TO_DCHAR (arg, arg_end - arg, 2120| | converted, &converted_len); 2121| |# endif 2122| | if (converted == NULL) 2123| | { 2124| | int saved_errno = errno; 2125| | if (!(result == resultbuf || result == NULL)) 2126| | free (result); 2127| | if (buf_malloced != NULL) 2128| | free (buf_malloced); 2129| | CLEANUP (); 2130| | errno = saved_errno; 2131| | return NULL; 2132| | } 2133| | if (converted != result + length) 2134| | { 2135| | ENSURE_ALLOCATION (xsum (length, converted_len)); 2136| | DCHAR_CPY (result + length, converted, converted_len); 2137| | free (converted); 2138| | } 2139| | length += converted_len; 2140| | } 2141| |# endif 2142| | 2143| | if (characters < width && (dp->flags & FLAG_LEFT)) 2144| | { 2145| | size_t n = width - characters; 2146| | ENSURE_ALLOCATION (xsum (length, n)); 2147| | DCHAR_SET (result + length, ' ', n); 2148| | length += n; 2149| | } 2150| | } 2151| | break; 2152| | 2153| | case TYPE_U16_STRING: 2154| | { 2155| | const uint16_t *arg = a.arg[dp->arg_index].a.a_u16_string; 2156| | const uint16_t *arg_end; 2157| | size_t characters; 2158| | 2159| | if (has_precision) 2160| | { 2161| | /* Use only PRECISION characters, from the left. */ 2162| | arg_end = arg; 2163| | characters = 0; 2164| | for (; precision > 0; precision--) 2165| | { 2166| | int count = u16_strmblen (arg_end); 2167| | if (count == 0) 2168| | break; 2169| | if (count < 0) 2170| | { 2171| | if (!(result == resultbuf || result == NULL)) 2172| | free (result); 2173| | if (buf_malloced != NULL) 2174| | free (buf_malloced); 2175| | CLEANUP (); 2176| | errno = EILSEQ; 2177| | return NULL; 2178| | } 2179| | arg_end += count; 2180| | characters++; 2181| | } 2182| | } 2183| | else if (has_width) 2184| | { 2185| | /* Use the entire string, and count the number of 2186| | characters. */ 2187| | arg_end = arg; 2188| | characters = 0; 2189| | for (;;) 2190| | { 2191| | int count = u16_strmblen (arg_end); 2192| | if (count == 0) 2193| | break; 2194| | if (count < 0) 2195| | { 2196| | if (!(result == resultbuf || result == NULL)) 2197| | free (result); 2198| | if (buf_malloced != NULL) 2199| | free (buf_malloced); 2200| | CLEANUP (); 2201| | errno = EILSEQ; 2202| | return NULL; 2203| | } 2204| | arg_end += count; 2205| | characters++; 2206| | } 2207| | } 2208| | else 2209| | { 2210| | /* Use the entire string. */ 2211| | arg_end = arg + u16_strlen (arg); 2212| | /* The number of characters doesn't matter. */ 2213| | characters = 0; 2214| | } 2215| | 2216| | if (characters < width && !(dp->flags & FLAG_LEFT)) 2217| | { 2218| | size_t n = width - characters; 2219| | ENSURE_ALLOCATION (xsum (length, n)); 2220| | DCHAR_SET (result + length, ' ', n); 2221| | length += n; 2222| | } 2223| | 2224| |# if DCHAR_IS_UINT16_T 2225| | { 2226| | size_t n = arg_end - arg; 2227| | ENSURE_ALLOCATION (xsum (length, n)); 2228| | DCHAR_CPY (result + length, arg, n); 2229| | length += n; 2230| | } 2231| |# else 2232| | { /* Convert. */ 2233| | DCHAR_T *converted = result + length; 2234| | size_t converted_len = allocated - length; 2235| |# if DCHAR_IS_TCHAR 2236| | /* Convert from UTF-16 to locale encoding. */ 2237| | converted = 2238| | u16_conv_to_encoding (locale_charset (), 2239| | iconveh_question_mark, 2240| | arg, arg_end - arg, NULL, 2241| | converted, &converted_len); 2242| |# else 2243| | /* Convert from UTF-16 to UTF-8/UTF-32. */ 2244| | converted = 2245| | U16_TO_DCHAR (arg, arg_end - arg, 2246| | converted, &converted_len); 2247| |# endif 2248| | if (converted == NULL) 2249| | { 2250| | int saved_errno = errno; 2251| | if (!(result == resultbuf || result == NULL)) 2252| | free (result); 2253| | if (buf_malloced != NULL) 2254| | free (buf_malloced); 2255| | CLEANUP (); 2256| | errno = saved_errno; 2257| | return NULL; 2258| | } 2259| | if (converted != result + length) 2260| | { 2261| | ENSURE_ALLOCATION (xsum (length, converted_len)); 2262| | DCHAR_CPY (result + length, converted, converted_len); 2263| | free (converted); 2264| | } 2265| | length += converted_len; 2266| | } 2267| |# endif 2268| | 2269| | if (characters < width && (dp->flags & FLAG_LEFT)) 2270| | { 2271| | size_t n = width - characters; 2272| | ENSURE_ALLOCATION (xsum (length, n)); 2273| | DCHAR_SET (result + length, ' ', n); 2274| | length += n; 2275| | } 2276| | } 2277| | break; 2278| | 2279| | case TYPE_U32_STRING: 2280| | { 2281| | const uint32_t *arg = a.arg[dp->arg_index].a.a_u32_string; 2282| | const uint32_t *arg_end; 2283| | size_t characters; 2284| | 2285| | if (has_precision) 2286| | { 2287| | /* Use only PRECISION characters, from the left. */ 2288| | arg_end = arg; 2289| | characters = 0; 2290| | for (; precision > 0; precision--) 2291| | { 2292| | int count = u32_strmblen (arg_end); 2293| | if (count == 0) 2294| | break; 2295| | if (count < 0) 2296| | { 2297| | if (!(result == resultbuf || result == NULL)) 2298| | free (result); 2299| | if (buf_malloced != NULL) 2300| | free (buf_malloced); 2301| | CLEANUP (); 2302| | errno = EILSEQ; 2303| | return NULL; 2304| | } 2305| | arg_end += count; 2306| | characters++; 2307| | } 2308| | } 2309| | else if (has_width) 2310| | { 2311| | /* Use the entire string, and count the number of 2312| | characters. */ 2313| | arg_end = arg; 2314| | characters = 0; 2315| | for (;;) 2316| | { 2317| | int count = u32_strmblen (arg_end); 2318| | if (count == 0) 2319| | break; 2320| | if (count < 0) 2321| | { 2322| | if (!(result == resultbuf || result == NULL)) 2323| | free (result); 2324| | if (buf_malloced != NULL) 2325| | free (buf_malloced); 2326| | CLEANUP (); 2327| | errno = EILSEQ; 2328| | return NULL; 2329| | } 2330| | arg_end += count; 2331| | characters++; 2332| | } 2333| | } 2334| | else 2335| | { 2336| | /* Use the entire string. */ 2337| | arg_end = arg + u32_strlen (arg); 2338| | /* The number of characters doesn't matter. */ 2339| | characters = 0; 2340| | } 2341| | 2342| | if (characters < width && !(dp->flags & FLAG_LEFT)) 2343| | { 2344| | size_t n = width - characters; 2345| | ENSURE_ALLOCATION (xsum (length, n)); 2346| | DCHAR_SET (result + length, ' ', n); 2347| | length += n; 2348| | } 2349| | 2350| |# if DCHAR_IS_UINT32_T 2351| | { 2352| | size_t n = arg_end - arg; 2353| | ENSURE_ALLOCATION (xsum (length, n)); 2354| | DCHAR_CPY (result + length, arg, n); 2355| | length += n; 2356| | } 2357| |# else 2358| | { /* Convert. */ 2359| | DCHAR_T *converted = result + length; 2360| | size_t converted_len = allocated - length; 2361| |# if DCHAR_IS_TCHAR 2362| | /* Convert from UTF-32 to locale encoding. */ 2363| | converted = 2364| | u32_conv_to_encoding (locale_charset (), 2365| | iconveh_question_mark, 2366| | arg, arg_end - arg, NULL, 2367| | converted, &converted_len); 2368| |# else 2369| | /* Convert from UTF-32 to UTF-8/UTF-16. */ 2370| | converted = 2371| | U32_TO_DCHAR (arg, arg_end - arg, 2372| | converted, &converted_len); 2373| |# endif 2374| | if (converted == NULL) 2375| | { 2376| | int saved_errno = errno; 2377| | if (!(result == resultbuf || result == NULL)) 2378| | free (result); 2379| | if (buf_malloced != NULL) 2380| | free (buf_malloced); 2381| | CLEANUP (); 2382| | errno = saved_errno; 2383| | return NULL; 2384| | } 2385| | if (converted != result + length) 2386| | { 2387| | ENSURE_ALLOCATION (xsum (length, converted_len)); 2388| | DCHAR_CPY (result + length, converted, converted_len); 2389| | free (converted); 2390| | } 2391| | length += converted_len; 2392| | } 2393| |# endif 2394| | 2395| | if (characters < width && (dp->flags & FLAG_LEFT)) 2396| | { 2397| | size_t n = width - characters; 2398| | ENSURE_ALLOCATION (xsum (length, n)); 2399| | DCHAR_SET (result + length, ' ', n); 2400| | length += n; 2401| | } 2402| | } 2403| | break; 2404| | 2405| | default: 2406| | abort (); 2407| | } 2408| | } 2409| |#endif 2410| 484k|#if (!USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || (NEED_PRINTF_DIRECTIVE_LS && !defined IN_LIBINTL)) && HAVE_WCHAR_T 2411| 484k| else if (dp->conversion == 's' ------------------ | Branch (2411:22): [True: 146k, False: 337k] ------------------ 2412| |# if WIDE_CHAR_VERSION 2413| | && a.arg[dp->arg_index].type != TYPE_WIDE_STRING 2414| |# else 2415| 146k| && a.arg[dp->arg_index].type == TYPE_WIDE_STRING ------------------ | Branch (2415:25): [True: 0, False: 146k] ------------------ 2416| 484k|# endif 2417| 484k| ) 2418| 0| { 2419| | /* The normal handling of the 's' directive below requires 2420| | allocating a temporary buffer. The determination of its 2421| | length (tmp_length), in the case when a precision is 2422| | specified, below requires a conversion between a char[] 2423| | string and a wchar_t[] wide string. It could be done, but 2424| | we have no guarantee that the implementation of sprintf will 2425| | use the exactly same algorithm. Without this guarantee, it 2426| | is possible to have buffer overrun bugs. In order to avoid 2427| | such bugs, we implement the entire processing of the 's' 2428| | directive ourselves. */ 2429| 0| int flags = dp->flags; 2430| 0| int has_width; 2431| 0| size_t width; 2432| 0| int has_precision; 2433| 0| size_t precision; 2434| | 2435| 0| has_width = 0; 2436| 0| width = 0; 2437| 0| if (dp->width_start != dp->width_end) ------------------ | Branch (2437:21): [True: 0, False: 0] ------------------ 2438| 0| { 2439| 0| if (dp->width_arg_index != ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (2439:25): [True: 0, False: 0] ------------------ 2440| 0| { 2441| 0| int arg; 2442| | 2443| 0| if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) ------------------ | Branch (2443:29): [True: 0, False: 0] ------------------ 2444| 0| abort (); 2445| 0| arg = a.arg[dp->width_arg_index].a.a_int; 2446| 0| width = arg; 2447| 0| if (arg < 0) ------------------ | Branch (2447:29): [True: 0, False: 0] ------------------ 2448| 0| { 2449| | /* "A negative field width is taken as a '-' flag 2450| | followed by a positive field width." */ 2451| 0| flags |= FLAG_LEFT; ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ 2452| 0| width = -width; 2453| 0| } 2454| 0| } 2455| 0| else 2456| 0| { 2457| 0| const FCHAR_T *digitp = dp->width_start; 2458| | 2459| 0| do 2460| 0| width = xsum (xtimes (width, 10), *digitp++ - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 2461| 0| while (digitp != dp->width_end); ------------------ | Branch (2461:32): [True: 0, False: 0] ------------------ 2462| 0| } 2463| 0| has_width = 1; 2464| 0| } 2465| | 2466| 0| has_precision = 0; 2467| 0| precision = 6; 2468| 0| if (dp->precision_start != dp->precision_end) ------------------ | Branch (2468:21): [True: 0, False: 0] ------------------ 2469| 0| { 2470| 0| if (dp->precision_arg_index != ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (2470:25): [True: 0, False: 0] ------------------ 2471| 0| { 2472| 0| int arg; 2473| | 2474| 0| if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) ------------------ | Branch (2474:29): [True: 0, False: 0] ------------------ 2475| 0| abort (); 2476| 0| arg = a.arg[dp->precision_arg_index].a.a_int; 2477| | /* "A negative precision is taken as if the precision 2478| | were omitted." */ 2479| 0| if (arg >= 0) ------------------ | Branch (2479:29): [True: 0, False: 0] ------------------ 2480| 0| { 2481| 0| precision = arg; 2482| 0| has_precision = 1; 2483| 0| } 2484| 0| } 2485| 0| else 2486| 0| { 2487| 0| const FCHAR_T *digitp = dp->precision_start + 1; 2488| | 2489| 0| precision = 0; 2490| 0| while (digitp != dp->precision_end) ------------------ | Branch (2490:32): [True: 0, False: 0] ------------------ 2491| 0| precision = xsum (xtimes (precision, 10), *digitp++ - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 2492| 0| has_precision = 1; 2493| 0| } 2494| 0| } 2495| | 2496| |# if WIDE_CHAR_VERSION 2497| | /* %s in vasnwprintf. See the specification of fwprintf. */ 2498| | { 2499| | const char *arg = a.arg[dp->arg_index].a.a_string; 2500| | const char *arg_end; 2501| | size_t characters; 2502| | 2503| | if (has_precision) 2504| | { 2505| | /* Use only as many bytes as needed to produce PRECISION 2506| | wide characters, from the left. */ 2507| |# if HAVE_MBRTOWC 2508| | mbstate_t state; 2509| | memset (&state, '\0', sizeof (mbstate_t)); 2510| |# endif 2511| | arg_end = arg; 2512| | characters = 0; 2513| | for (; precision > 0; precision--) 2514| | { 2515| | int count; 2516| |# if HAVE_MBRTOWC 2517| | count = mbrlen (arg_end, MB_CUR_MAX, &state); 2518| |# else 2519| | count = mblen (arg_end, MB_CUR_MAX); 2520| |# endif 2521| | if (count == 0) 2522| | /* Found the terminating NUL. */ 2523| | break; 2524| | if (count < 0) 2525| | { 2526| | /* Invalid or incomplete multibyte character. */ 2527| | if (!(result == resultbuf || result == NULL)) 2528| | free (result); 2529| | if (buf_malloced != NULL) 2530| | free (buf_malloced); 2531| | CLEANUP (); 2532| | errno = EILSEQ; 2533| | return NULL; 2534| | } 2535| | arg_end += count; 2536| | characters++; 2537| | } 2538| | } 2539| | else if (has_width) 2540| | { 2541| | /* Use the entire string, and count the number of wide 2542| | characters. */ 2543| |# if HAVE_MBRTOWC 2544| | mbstate_t state; 2545| | memset (&state, '\0', sizeof (mbstate_t)); 2546| |# endif 2547| | arg_end = arg; 2548| | characters = 0; 2549| | for (;;) 2550| | { 2551| | int count; 2552| |# if HAVE_MBRTOWC 2553| | count = mbrlen (arg_end, MB_CUR_MAX, &state); 2554| |# else 2555| | count = mblen (arg_end, MB_CUR_MAX); 2556| |# endif 2557| | if (count == 0) 2558| | /* Found the terminating NUL. */ 2559| | break; 2560| | if (count < 0) 2561| | { 2562| | /* Invalid or incomplete multibyte character. */ 2563| | if (!(result == resultbuf || result == NULL)) 2564| | free (result); 2565| | if (buf_malloced != NULL) 2566| | free (buf_malloced); 2567| | CLEANUP (); 2568| | errno = EILSEQ; 2569| | return NULL; 2570| | } 2571| | arg_end += count; 2572| | characters++; 2573| | } 2574| | } 2575| | else 2576| | { 2577| | /* Use the entire string. */ 2578| | arg_end = arg + strlen (arg); 2579| | /* The number of characters doesn't matter. */ 2580| | characters = 0; 2581| | } 2582| | 2583| | if (characters < width && !(dp->flags & FLAG_LEFT)) 2584| | { 2585| | size_t n = width - characters; 2586| | ENSURE_ALLOCATION (xsum (length, n)); 2587| | DCHAR_SET (result + length, ' ', n); 2588| | length += n; 2589| | } 2590| | 2591| | if (has_precision || has_width) 2592| | { 2593| | /* We know the number of wide characters in advance. */ 2594| | size_t remaining; 2595| |# if HAVE_MBRTOWC 2596| | mbstate_t state; 2597| | memset (&state, '\0', sizeof (mbstate_t)); 2598| |# endif 2599| | ENSURE_ALLOCATION (xsum (length, characters)); 2600| | for (remaining = characters; remaining > 0; remaining--) 2601| | { 2602| | wchar_t wc; 2603| | int count; 2604| |# if HAVE_MBRTOWC 2605| | count = mbrtowc (&wc, arg, arg_end - arg, &state); 2606| |# else 2607| | count = mbtowc (&wc, arg, arg_end - arg); 2608| |# endif 2609| | if (count <= 0) 2610| | /* mbrtowc not consistent with mbrlen, or mbtowc 2611| | not consistent with mblen. */ 2612| | abort (); 2613| | result[length++] = wc; 2614| | arg += count; 2615| | } 2616| | if (!(arg == arg_end)) 2617| | abort (); 2618| | } 2619| | else 2620| | { 2621| |# if HAVE_MBRTOWC 2622| | mbstate_t state; 2623| | memset (&state, '\0', sizeof (mbstate_t)); 2624| |# endif 2625| | while (arg < arg_end) 2626| | { 2627| | wchar_t wc; 2628| | int count; 2629| |# if HAVE_MBRTOWC 2630| | count = mbrtowc (&wc, arg, arg_end - arg, &state); 2631| |# else 2632| | count = mbtowc (&wc, arg, arg_end - arg); 2633| |# endif 2634| | if (count <= 0) 2635| | /* mbrtowc not consistent with mbrlen, or mbtowc 2636| | not consistent with mblen. */ 2637| | abort (); 2638| | ENSURE_ALLOCATION (xsum (length, 1)); 2639| | result[length++] = wc; 2640| | arg += count; 2641| | } 2642| | } 2643| | 2644| | if (characters < width && (dp->flags & FLAG_LEFT)) 2645| | { 2646| | size_t n = width - characters; 2647| | ENSURE_ALLOCATION (xsum (length, n)); 2648| | DCHAR_SET (result + length, ' ', n); 2649| | length += n; 2650| | } 2651| | } 2652| |# else 2653| | /* %ls in vasnprintf. See the specification of fprintf. */ 2654| 0| { 2655| 0| const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string; 2656| 0| const wchar_t *arg_end; 2657| 0| size_t characters; 2658| |# if !DCHAR_IS_TCHAR 2659| | /* This code assumes that TCHAR_T is 'char'. */ 2660| | verify (sizeof (TCHAR_T) == 1); 2661| | TCHAR_T *tmpsrc; 2662| | DCHAR_T *tmpdst; 2663| | size_t tmpdst_len; 2664| |# endif 2665| 0| size_t w; 2666| | 2667| 0| if (has_precision) ------------------ | Branch (2667:23): [True: 0, False: 0] ------------------ 2668| 0| { 2669| | /* Use only as many wide characters as needed to produce 2670| | at most PRECISION bytes, from the left. */ 2671| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2672| 0| mbstate_t state; 2673| 0| memset (&state, '\0', sizeof (mbstate_t)); 2674| 0|# endif 2675| 0| arg_end = arg; 2676| 0| characters = 0; 2677| 0| while (precision > 0) ------------------ | Branch (2677:30): [True: 0, False: 0] ------------------ 2678| 0| { 2679| 0| char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */ 2680| 0| int count; 2681| | 2682| 0| if (*arg_end == 0) ------------------ | Branch (2682:31): [True: 0, False: 0] ------------------ 2683| | /* Found the terminating null wide character. */ 2684| 0| break; 2685| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2686| 0| count = wcrtomb (cbuf, *arg_end, &state); 2687| |# else 2688| | count = wctomb (cbuf, *arg_end); 2689| |# endif 2690| 0| if (count < 0) ------------------ | Branch (2690:31): [True: 0, False: 0] ------------------ 2691| 0| { 2692| | /* Cannot convert. */ 2693| 0| if (!(result == resultbuf || result == NULL)) ------------------ | Branch (2693:37): [True: 0, False: 0] | Branch (2693:60): [True: 0, False: 0] ------------------ 2694| 0| free (result); ------------------ | | 35| 0|#define free g_free ------------------ 2695| 0| if (buf_malloced != NULL) ------------------ | Branch (2695:35): [True: 0, False: 0] ------------------ 2696| 0| free (buf_malloced); ------------------ | | 35| 0|#define free g_free ------------------ 2697| 0| CLEANUP (); ------------------ | | 1799| 0| if (d.dir != d.direct_alloc_dir) \ | | ------------------ | | | Branch (1799:7): [True: 0, False: 0] | | ------------------ | | 1800| 0| free (d.dir); \ | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ | | 1801| 0| if (a.arg != a.direct_alloc_arg) \ | | ------------------ | | | Branch (1801:7): [True: 0, False: 0] | | ------------------ | | 1802| 0| free (a.arg); | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ ------------------ 2698| 0| errno = EILSEQ; 2699| 0| return NULL; 2700| 0| } 2701| 0| if (precision < (unsigned int) count) ------------------ | Branch (2701:31): [True: 0, False: 0] ------------------ 2702| 0| break; 2703| 0| arg_end++; 2704| 0| characters += count; 2705| 0| precision -= count; 2706| 0| } 2707| 0| } 2708| 0|# if DCHAR_IS_TCHAR 2709| 0| else if (has_width) ------------------ | Branch (2709:28): [True: 0, False: 0] ------------------ 2710| |# else 2711| | else 2712| |# endif 2713| 0| { 2714| | /* Use the entire string, and count the number of 2715| | bytes. */ 2716| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2717| 0| mbstate_t state; 2718| 0| memset (&state, '\0', sizeof (mbstate_t)); 2719| 0|# endif 2720| 0| arg_end = arg; 2721| 0| characters = 0; 2722| 0| for (;;) 2723| 0| { 2724| 0| char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */ 2725| 0| int count; 2726| | 2727| 0| if (*arg_end == 0) ------------------ | Branch (2727:31): [True: 0, False: 0] ------------------ 2728| | /* Found the terminating null wide character. */ 2729| 0| break; 2730| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2731| 0| count = wcrtomb (cbuf, *arg_end, &state); 2732| |# else 2733| | count = wctomb (cbuf, *arg_end); 2734| |# endif 2735| 0| if (count < 0) ------------------ | Branch (2735:31): [True: 0, False: 0] ------------------ 2736| 0| { 2737| | /* Cannot convert. */ 2738| 0| if (!(result == resultbuf || result == NULL)) ------------------ | Branch (2738:37): [True: 0, False: 0] | Branch (2738:60): [True: 0, False: 0] ------------------ 2739| 0| free (result); ------------------ | | 35| 0|#define free g_free ------------------ 2740| 0| if (buf_malloced != NULL) ------------------ | Branch (2740:35): [True: 0, False: 0] ------------------ 2741| 0| free (buf_malloced); ------------------ | | 35| 0|#define free g_free ------------------ 2742| 0| CLEANUP (); ------------------ | | 1799| 0| if (d.dir != d.direct_alloc_dir) \ | | ------------------ | | | Branch (1799:7): [True: 0, False: 0] | | ------------------ | | 1800| 0| free (d.dir); \ | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ | | 1801| 0| if (a.arg != a.direct_alloc_arg) \ | | ------------------ | | | Branch (1801:7): [True: 0, False: 0] | | ------------------ | | 1802| 0| free (a.arg); | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ ------------------ 2743| 0| errno = EILSEQ; 2744| 0| return NULL; 2745| 0| } 2746| 0| arg_end++; 2747| 0| characters += count; 2748| 0| } 2749| 0| } 2750| 0|# if DCHAR_IS_TCHAR 2751| 0| else 2752| 0| { 2753| | /* Use the entire string. */ 2754| 0| arg_end = arg + local_wcslen (arg); ------------------ | | 242| 0|# define local_wcslen wcslen ------------------ 2755| | /* The number of bytes doesn't matter. */ 2756| 0| characters = 0; 2757| 0| } 2758| 0|# endif 2759| | 2760| |# if !DCHAR_IS_TCHAR 2761| | /* Convert the string into a piece of temporary memory. */ 2762| | tmpsrc = (TCHAR_T *) malloc (characters * sizeof (TCHAR_T)); 2763| | if (tmpsrc == NULL) 2764| | goto out_of_memory; 2765| | { 2766| | TCHAR_T *tmpptr = tmpsrc; 2767| | size_t remaining; 2768| |# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2769| | mbstate_t state; 2770| | memset (&state, '\0', sizeof (mbstate_t)); 2771| |# endif 2772| | for (remaining = characters; remaining > 0; ) 2773| | { 2774| | char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */ 2775| | int count; 2776| | 2777| | if (*arg == 0) 2778| | abort (); 2779| |# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2780| | count = wcrtomb (cbuf, *arg, &state); 2781| |# else 2782| | count = wctomb (cbuf, *arg); 2783| |# endif 2784| | if (count <= 0) 2785| | /* Inconsistency. */ 2786| | abort (); 2787| | memcpy (tmpptr, cbuf, count); 2788| | tmpptr += count; 2789| | arg++; 2790| | remaining -= count; 2791| | } 2792| | if (!(arg == arg_end)) 2793| | abort (); 2794| | } 2795| | 2796| | /* Convert from TCHAR_T[] to DCHAR_T[]. */ 2797| | tmpdst = 2798| | DCHAR_CONV_FROM_ENCODING (locale_charset (), 2799| | iconveh_question_mark, 2800| | tmpsrc, characters, 2801| | NULL, 2802| | NULL, &tmpdst_len); 2803| | if (tmpdst == NULL) 2804| | { 2805| | int saved_errno = errno; 2806| | free (tmpsrc); 2807| | if (!(result == resultbuf || result == NULL)) 2808| | free (result); 2809| | if (buf_malloced != NULL) 2810| | free (buf_malloced); 2811| | CLEANUP (); 2812| | errno = saved_errno; 2813| | return NULL; 2814| | } 2815| | free (tmpsrc); 2816| |# endif 2817| | 2818| 0| if (has_width) ------------------ | Branch (2818:23): [True: 0, False: 0] ------------------ 2819| 0| { 2820| |# if ENABLE_UNISTDIO 2821| | /* Outside POSIX, it's preferable to compare the width 2822| | against the number of _characters_ of the converted 2823| | value. */ 2824| | w = DCHAR_MBSNLEN (result + length, characters); 2825| |# else 2826| | /* The width is compared against the number of _bytes_ 2827| | of the converted value, says POSIX. */ 2828| 0| w = characters; 2829| 0|# endif 2830| 0| } 2831| 0| else 2832| | /* w doesn't matter. */ 2833| 0| w = 0; 2834| | 2835| 0| if (w < width && !(dp->flags & FLAG_LEFT)) ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ | Branch (2835:23): [True: 0, False: 0] | Branch (2835:36): [True: 0, False: 0] ------------------ 2836| 0| { 2837| 0| size_t n = width - w; 2838| 0| ENSURE_ALLOCATION (xsum (length, n)); ------------------ | | 1863| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 0, False: 0] | | ------------------ | | 1864| 0| { \ | | 1865| 0| size_t memory_size; \ | | 1866| 0| DCHAR_T *memory; \ | | ------------------ | | | | 147| 0|# define DCHAR_T char | | ------------------ | | 1867| 0| \ | | 1868| 0| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 0, False: 0] | | ------------------ | | 1869| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 0] | | ------------------ | | 1870| 0| allocated = (needed); \ | | 1871| 0| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1872| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1873| 0| goto out_of_memory; \ | | 1874| 0| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 0] | | | Branch (1874:36): [True: 0, False: 0] | | ------------------ | | 1875| 0| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 0| else \ | | 1877| 0| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 1878| 0| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 0] | | ------------------ | | 1879| 0| goto out_of_memory; \ | | 1880| 0| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 0] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 0| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 0| result = memory; \ | | 1883| 0| } ------------------ 2839| 0| DCHAR_SET (result + length, ' ', n); ------------------ | | 154| 0|# define DCHAR_SET memset ------------------ 2840| 0| length += n; 2841| 0| } 2842| | 2843| 0|# if DCHAR_IS_TCHAR 2844| 0| if (has_precision || has_width) ------------------ | Branch (2844:23): [True: 0, False: 0] | Branch (2844:40): [True: 0, False: 0] ------------------ 2845| 0| { 2846| | /* We know the number of bytes in advance. */ 2847| 0| size_t remaining; 2848| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2849| 0| mbstate_t state; 2850| 0| memset (&state, '\0', sizeof (mbstate_t)); 2851| 0|# endif 2852| 0| ENSURE_ALLOCATION (xsum (length, characters)); ------------------ | | 1863| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 0, False: 0] | | ------------------ | | 1864| 0| { \ | | 1865| 0| size_t memory_size; \ | | 1866| 0| DCHAR_T *memory; \ | | ------------------ | | | | 147| 0|# define DCHAR_T char | | ------------------ | | 1867| 0| \ | | 1868| 0| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 0, False: 0] | | ------------------ | | 1869| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 0] | | ------------------ | | 1870| 0| allocated = (needed); \ | | 1871| 0| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1872| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1873| 0| goto out_of_memory; \ | | 1874| 0| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 0] | | | Branch (1874:36): [True: 0, False: 0] | | ------------------ | | 1875| 0| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 0| else \ | | 1877| 0| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 1878| 0| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 0] | | ------------------ | | 1879| 0| goto out_of_memory; \ | | 1880| 0| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 0] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 0| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 0| result = memory; \ | | 1883| 0| } ------------------ 2853| 0| for (remaining = characters; remaining > 0; ) ------------------ | Branch (2853:52): [True: 0, False: 0] ------------------ 2854| 0| { 2855| 0| char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */ 2856| 0| int count; 2857| | 2858| 0| if (*arg == 0) ------------------ | Branch (2858:31): [True: 0, False: 0] ------------------ 2859| 0| abort (); 2860| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2861| 0| count = wcrtomb (cbuf, *arg, &state); 2862| |# else 2863| | count = wctomb (cbuf, *arg); 2864| |# endif 2865| 0| if (count <= 0) ------------------ | Branch (2865:31): [True: 0, False: 0] ------------------ 2866| | /* Inconsistency. */ 2867| 0| abort (); 2868| 0| memcpy (result + length, cbuf, count); 2869| 0| length += count; 2870| 0| arg++; 2871| 0| remaining -= count; 2872| 0| } 2873| 0| if (!(arg == arg_end)) ------------------ | Branch (2873:27): [True: 0, False: 0] ------------------ 2874| 0| abort (); 2875| 0| } 2876| 0| else 2877| 0| { 2878| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2879| 0| mbstate_t state; 2880| 0| memset (&state, '\0', sizeof (mbstate_t)); 2881| 0|# endif 2882| 0| while (arg < arg_end) ------------------ | Branch (2882:30): [True: 0, False: 0] ------------------ 2883| 0| { 2884| 0| char cbuf[64]; /* Assume MB_CUR_MAX <= 64. */ 2885| 0| int count; 2886| | 2887| 0| if (*arg == 0) ------------------ | Branch (2887:31): [True: 0, False: 0] ------------------ 2888| 0| abort (); 2889| 0|# if HAVE_WCRTOMB && !defined GNULIB_defined_mbstate_t 2890| 0| count = wcrtomb (cbuf, *arg, &state); 2891| |# else 2892| | count = wctomb (cbuf, *arg); 2893| |# endif 2894| 0| if (count <= 0) ------------------ | Branch (2894:31): [True: 0, False: 0] ------------------ 2895| 0| { 2896| | /* Cannot convert. */ 2897| 0| if (!(result == resultbuf || result == NULL)) ------------------ | Branch (2897:37): [True: 0, False: 0] | Branch (2897:60): [True: 0, False: 0] ------------------ 2898| 0| free (result); ------------------ | | 35| 0|#define free g_free ------------------ 2899| 0| if (buf_malloced != NULL) ------------------ | Branch (2899:35): [True: 0, False: 0] ------------------ 2900| 0| free (buf_malloced); ------------------ | | 35| 0|#define free g_free ------------------ 2901| 0| CLEANUP (); ------------------ | | 1799| 0| if (d.dir != d.direct_alloc_dir) \ | | ------------------ | | | Branch (1799:7): [True: 0, False: 0] | | ------------------ | | 1800| 0| free (d.dir); \ | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ | | 1801| 0| if (a.arg != a.direct_alloc_arg) \ | | ------------------ | | | Branch (1801:7): [True: 0, False: 0] | | ------------------ | | 1802| 0| free (a.arg); | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ ------------------ 2902| 0| errno = EILSEQ; 2903| 0| return NULL; 2904| 0| } 2905| 0| ENSURE_ALLOCATION (xsum (length, count)); ------------------ | | 1863| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 0, False: 0] | | ------------------ | | 1864| 0| { \ | | 1865| 0| size_t memory_size; \ | | 1866| 0| DCHAR_T *memory; \ | | ------------------ | | | | 147| 0|# define DCHAR_T char | | ------------------ | | 1867| 0| \ | | 1868| 0| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 0, False: 0] | | ------------------ | | 1869| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 0] | | ------------------ | | 1870| 0| allocated = (needed); \ | | 1871| 0| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1872| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1873| 0| goto out_of_memory; \ | | 1874| 0| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 0] | | | Branch (1874:36): [True: 0, False: 0] | | ------------------ | | 1875| 0| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 0| else \ | | 1877| 0| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 1878| 0| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 0] | | ------------------ | | 1879| 0| goto out_of_memory; \ | | 1880| 0| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 0] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 0| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 0| result = memory; \ | | 1883| 0| } ------------------ 2906| 0| memcpy (result + length, cbuf, count); 2907| 0| length += count; 2908| 0| arg++; 2909| 0| } 2910| 0| } 2911| |# else 2912| | ENSURE_ALLOCATION (xsum (length, tmpdst_len)); 2913| | DCHAR_CPY (result + length, tmpdst, tmpdst_len); 2914| | free (tmpdst); 2915| | length += tmpdst_len; 2916| |# endif 2917| | 2918| 0| if (w < width && (dp->flags & FLAG_LEFT)) ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ | Branch (2918:23): [True: 0, False: 0] | Branch (2918:36): [True: 0, False: 0] ------------------ 2919| 0| { 2920| 0| size_t n = width - w; 2921| 0| ENSURE_ALLOCATION (xsum (length, n)); ------------------ | | 1863| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 0, False: 0] | | ------------------ | | 1864| 0| { \ | | 1865| 0| size_t memory_size; \ | | 1866| 0| DCHAR_T *memory; \ | | ------------------ | | | | 147| 0|# define DCHAR_T char | | ------------------ | | 1867| 0| \ | | 1868| 0| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 0, False: 0] | | ------------------ | | 1869| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 0] | | ------------------ | | 1870| 0| allocated = (needed); \ | | 1871| 0| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1872| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1873| 0| goto out_of_memory; \ | | 1874| 0| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 0] | | | Branch (1874:36): [True: 0, False: 0] | | ------------------ | | 1875| 0| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 0| else \ | | 1877| 0| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 1878| 0| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 0] | | ------------------ | | 1879| 0| goto out_of_memory; \ | | 1880| 0| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 0] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 0| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 0| result = memory; \ | | 1883| 0| } ------------------ 2922| 0| DCHAR_SET (result + length, ' ', n); ------------------ | | 154| 0|# define DCHAR_SET memset ------------------ 2923| 0| length += n; 2924| 0| } 2925| 0| } 2926| 0|# endif 2927| 0| } 2928| 484k|#endif 2929| 484k|#if (NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_DOUBLE) && !defined IN_LIBINTL 2930| 484k| else if ((dp->conversion == 'a' || dp->conversion == 'A') ------------------ | Branch (2930:23): [True: 0, False: 484k] | Branch (2930:48): [True: 0, False: 484k] ------------------ 2931| |# if !(NEED_PRINTF_DIRECTIVE_A || (NEED_PRINTF_LONG_DOUBLE && NEED_PRINTF_DOUBLE)) 2932| | && (0 2933| |# if NEED_PRINTF_DOUBLE 2934| | || a.arg[dp->arg_index].type == TYPE_DOUBLE 2935| |# endif 2936| |# if NEED_PRINTF_LONG_DOUBLE 2937| | || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE 2938| |# endif 2939| | ) 2940| |# endif 2941| 484k| ) 2942| 0| { 2943| 0| arg_type type = a.arg[dp->arg_index].type; 2944| 0| int flags = dp->flags; 2945| 0| size_t width; 2946| 0| int has_precision; 2947| 0| size_t precision; 2948| 0| size_t tmp_length; 2949| 0| size_t count; 2950| 0| DCHAR_T tmpbuf[700]; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 2951| 0| DCHAR_T *tmp; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 2952| 0| DCHAR_T *pad_ptr; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 2953| 0| DCHAR_T *p; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 2954| | 2955| 0| width = 0; 2956| 0| if (dp->width_start != dp->width_end) ------------------ | Branch (2956:21): [True: 0, False: 0] ------------------ 2957| 0| { 2958| 0| if (dp->width_arg_index != ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (2958:25): [True: 0, False: 0] ------------------ 2959| 0| { 2960| 0| int arg; 2961| | 2962| 0| if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) ------------------ | Branch (2962:29): [True: 0, False: 0] ------------------ 2963| 0| abort (); 2964| 0| arg = a.arg[dp->width_arg_index].a.a_int; 2965| 0| width = arg; 2966| 0| if (arg < 0) ------------------ | Branch (2966:29): [True: 0, False: 0] ------------------ 2967| 0| { 2968| | /* "A negative field width is taken as a '-' flag 2969| | followed by a positive field width." */ 2970| 0| flags |= FLAG_LEFT; ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ 2971| 0| width = -width; 2972| 0| } 2973| 0| } 2974| 0| else 2975| 0| { 2976| 0| const FCHAR_T *digitp = dp->width_start; 2977| | 2978| 0| do 2979| 0| width = xsum (xtimes (width, 10), *digitp++ - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 2980| 0| while (digitp != dp->width_end); ------------------ | Branch (2980:32): [True: 0, False: 0] ------------------ 2981| 0| } 2982| 0| } 2983| | 2984| 0| has_precision = 0; 2985| 0| precision = 0; 2986| 0| if (dp->precision_start != dp->precision_end) ------------------ | Branch (2986:21): [True: 0, False: 0] ------------------ 2987| 0| { 2988| 0| if (dp->precision_arg_index != ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (2988:25): [True: 0, False: 0] ------------------ 2989| 0| { 2990| 0| int arg; 2991| | 2992| 0| if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) ------------------ | Branch (2992:29): [True: 0, False: 0] ------------------ 2993| 0| abort (); 2994| 0| arg = a.arg[dp->precision_arg_index].a.a_int; 2995| | /* "A negative precision is taken as if the precision 2996| | were omitted." */ 2997| 0| if (arg >= 0) ------------------ | Branch (2997:29): [True: 0, False: 0] ------------------ 2998| 0| { 2999| 0| precision = arg; 3000| 0| has_precision = 1; 3001| 0| } 3002| 0| } 3003| 0| else 3004| 0| { 3005| 0| const FCHAR_T *digitp = dp->precision_start + 1; 3006| | 3007| 0| precision = 0; 3008| 0| while (digitp != dp->precision_end) ------------------ | Branch (3008:32): [True: 0, False: 0] ------------------ 3009| 0| precision = xsum (xtimes (precision, 10), *digitp++ - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 3010| 0| has_precision = 1; 3011| 0| } 3012| 0| } 3013| | 3014| | /* Allocate a temporary buffer of sufficient size. */ 3015| 0| if (type == TYPE_LONGDOUBLE) ------------------ | Branch (3015:21): [True: 0, False: 0] ------------------ 3016| 0| tmp_length = 3017| 0| (unsigned int) ((LDBL_DIG + 1) 3018| 0| * 0.831 /* decimal -> hexadecimal */ 3019| 0| ) 3020| 0| + 1; /* turn floor into ceil */ 3021| 0| else 3022| 0| tmp_length = 3023| 0| (unsigned int) ((DBL_DIG + 1) 3024| 0| * 0.831 /* decimal -> hexadecimal */ 3025| 0| ) 3026| 0| + 1; /* turn floor into ceil */ 3027| 0| if (tmp_length < precision) ------------------ | Branch (3027:21): [True: 0, False: 0] ------------------ 3028| 0| tmp_length = precision; 3029| | /* Account for sign, decimal point etc. */ 3030| 0| tmp_length = xsum (tmp_length, 12); 3031| | 3032| 0| if (tmp_length < width) ------------------ | Branch (3032:21): [True: 0, False: 0] ------------------ 3033| 0| tmp_length = width; 3034| | 3035| 0| tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */ 3036| | 3037| 0| if (tmp_length <= sizeof (tmpbuf) / sizeof (DCHAR_T)) ------------------ | Branch (3037:21): [True: 0, False: 0] ------------------ 3038| 0| tmp = tmpbuf; 3039| 0| else 3040| 0| { 3041| 0| size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T)); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 3042| | 3043| 0| if (size_overflow_p (tmp_memsize)) ------------------ | | 112| 0| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 0] | | ------------------ ------------------ 3044| | /* Overflow, would lead to out of memory. */ 3045| 0| goto out_of_memory; 3046| 0| tmp = (DCHAR_T *) malloc (tmp_memsize); ------------------ | | 33| 0|#define malloc g_malloc ------------------ 3047| 0| if (tmp == NULL) ------------------ | Branch (3047:25): [True: 0, False: 0] ------------------ 3048| | /* Out of memory. */ 3049| 0| goto out_of_memory; 3050| 0| } 3051| | 3052| 0| pad_ptr = NULL; 3053| 0| p = tmp; 3054| 0| if (type == TYPE_LONGDOUBLE) ------------------ | Branch (3054:21): [True: 0, False: 0] ------------------ 3055| 0| { 3056| 0|# if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_LONG_DOUBLE 3057| 0| long double arg = a.arg[dp->arg_index].a.a_longdouble; 3058| | 3059| 0| if (isnanl (arg)) ------------------ | | 31| 0|# define isnanl rpl_isnanl ------------------ | Branch (3059:25): [True: 0, False: 0] ------------------ 3060| 0| { 3061| 0| if (dp->conversion == 'A') ------------------ | Branch (3061:29): [True: 0, False: 0] ------------------ 3062| 0| { 3063| 0| *p++ = 'N'; *p++ = 'A'; *p++ = 'N'; 3064| 0| } 3065| 0| else 3066| 0| { 3067| 0| *p++ = 'n'; *p++ = 'a'; *p++ = 'n'; 3068| 0| } 3069| 0| } 3070| 0| else 3071| 0| { 3072| 0| int sign = 0; 3073| 0| DECL_LONG_DOUBLE_ROUNDING ------------------ | | 84| 0| fpucw_t oldcw; ------------------ 3074| | 3075| 0| BEGIN_LONG_DOUBLE_ROUNDING (); ------------------ | | 86| 0| (void)(oldcw = GET_FPUCW (), \ | | ------------------ | | | | 74| 0| ({ fpucw_t _cw; \ | | | | 75| 0| __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_cw)); \ | | | | 76| 0| _cw; \ | | | | 77| 0| }) | | ------------------ | | 87| 0| SET_FPUCW ((oldcw & ~FPU_PC_MASK) | FPU_PC_EXTENDED)) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3076| | 3077| 0| if (signbit (arg)) /* arg < 0.0L or negative zero */ ------------------ | Branch (3077:29): [True: 0, False: 0] ------------------ 3078| 0| { 3079| 0| sign = -1; 3080| 0| arg = -arg; 3081| 0| } 3082| | 3083| 0| if (sign < 0) ------------------ | Branch (3083:29): [True: 0, False: 0] ------------------ 3084| 0| *p++ = '-'; 3085| 0| else if (flags & FLAG_SHOWSIGN) ------------------ | | 35| 0|#define FLAG_SHOWSIGN 4 /* + flag */ ------------------ | Branch (3085:34): [True: 0, False: 0] ------------------ 3086| 0| *p++ = '+'; 3087| 0| else if (flags & FLAG_SPACE) ------------------ | | 36| 0|#define FLAG_SPACE 8 /* space flag */ ------------------ | Branch (3087:34): [True: 0, False: 0] ------------------ 3088| 0| *p++ = ' '; 3089| | 3090| 0| if (arg > 0.0L && arg + arg == arg) ------------------ | Branch (3090:29): [True: 0, False: 0] | Branch (3090:43): [True: 0, False: 0] ------------------ 3091| 0| { 3092| 0| if (dp->conversion == 'A') ------------------ | Branch (3092:33): [True: 0, False: 0] ------------------ 3093| 0| { 3094| 0| *p++ = 'I'; *p++ = 'N'; *p++ = 'F'; 3095| 0| } 3096| 0| else 3097| 0| { 3098| 0| *p++ = 'i'; *p++ = 'n'; *p++ = 'f'; 3099| 0| } 3100| 0| } 3101| 0| else 3102| 0| { 3103| 0| int exponent; 3104| 0| long double mantissa; 3105| | 3106| 0| if (arg > 0.0L) ------------------ | Branch (3106:33): [True: 0, False: 0] ------------------ 3107| 0| mantissa = printf_frexpl (arg, &exponent); 3108| 0| else 3109| 0| { 3110| 0| exponent = 0; 3111| 0| mantissa = 0.0L; 3112| 0| } 3113| | 3114| 0| if (has_precision ------------------ | Branch (3114:33): [True: 0, False: 0] ------------------ 3115| 0| && precision < (unsigned int) ((LDBL_DIG + 1) * 0.831) + 1) ------------------ | Branch (3115:36): [True: 0, False: 0] ------------------ 3116| 0| { 3117| | /* Round the mantissa. */ 3118| 0| long double tail = mantissa; 3119| 0| size_t q; 3120| | 3121| 0| for (q = precision; ; q--) 3122| 0| { 3123| 0| int digit = (int) tail; 3124| 0| tail -= digit; 3125| 0| if (q == 0) ------------------ | Branch (3125:41): [True: 0, False: 0] ------------------ 3126| 0| { 3127| 0| if (digit & 1 ? tail >= 0.5L : tail > 0.5L) ------------------ | Branch (3127:45): [True: 0, False: 0] | Branch (3127:45): [True: 0, False: 0] ------------------ 3128| 0| tail = 1 - tail; 3129| 0| else 3130| 0| tail = - tail; 3131| 0| break; 3132| 0| } 3133| 0| tail *= 16.0L; 3134| 0| } 3135| 0| if (tail != 0.0L) ------------------ | Branch (3135:37): [True: 0, False: 0] ------------------ 3136| 0| for (q = precision; q > 0; q--) ------------------ | Branch (3136:55): [True: 0, False: 0] ------------------ 3137| 0| tail *= 0.0625L; 3138| 0| mantissa += tail; 3139| 0| } 3140| | 3141| 0| *p++ = '0'; 3142| 0| *p++ = dp->conversion - 'A' + 'X'; 3143| 0| pad_ptr = p; 3144| 0| { 3145| 0| int digit; 3146| | 3147| 0| digit = (int) mantissa; 3148| 0| mantissa -= digit; 3149| 0| *p++ = '0' + digit; 3150| 0| if ((flags & FLAG_ALT) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3150:35): [True: 0, False: 0] ------------------ 3151| 0| || mantissa > 0.0L || precision > 0) ------------------ | Branch (3151:38): [True: 0, False: 0] | Branch (3151:57): [True: 0, False: 0] ------------------ 3152| 0| { 3153| 0| *p++ = decimal_point_char (); 3154| | /* This loop terminates because we assume 3155| | that FLT_RADIX is a power of 2. */ 3156| 0| while (mantissa > 0.0L) ------------------ | Branch (3156:42): [True: 0, False: 0] ------------------ 3157| 0| { 3158| 0| mantissa *= 16.0L; 3159| 0| digit = (int) mantissa; 3160| 0| mantissa -= digit; 3161| 0| *p++ = digit 3162| 0| + (digit < 10 ------------------ | Branch (3162:49): [True: 0, False: 0] ------------------ 3163| 0| ? '0' 3164| 0| : dp->conversion - 10); 3165| 0| if (precision > 0) ------------------ | Branch (3165:43): [True: 0, False: 0] ------------------ 3166| 0| precision--; 3167| 0| } 3168| 0| while (precision > 0) ------------------ | Branch (3168:42): [True: 0, False: 0] ------------------ 3169| 0| { 3170| 0| *p++ = '0'; 3171| 0| precision--; 3172| 0| } 3173| 0| } 3174| 0| } 3175| 0| *p++ = dp->conversion - 'A' + 'P'; 3176| |# if WIDE_CHAR_VERSION 3177| | { 3178| | static const wchar_t decimal_format[] = 3179| | { '%', '+', 'd', '\0' }; 3180| | SNPRINTF (p, 6 + 1, decimal_format, exponent); 3181| | } 3182| | while (*p != '\0') 3183| | p++; 3184| |# else 3185| 0| if (sizeof (DCHAR_T) == 1) ------------------ | Branch (3185:35): [True: 0, Folded] ------------------ 3186| 0| { 3187| 0| sprintf ((char *) p, "%+d", exponent); 3188| 0| while (*p != '\0') ------------------ | Branch (3188:42): [True: 0, False: 0] ------------------ 3189| 0| p++; 3190| 0| } 3191| 0| else 3192| 0| { 3193| 0| char expbuf[6 + 1]; 3194| 0| const char *ep; 3195| 0| sprintf (expbuf, "%+d", exponent); 3196| 0| for (ep = expbuf; (*p = *ep) != '\0'; ep++) ------------------ | Branch (3196:53): [True: 0, False: 0] ------------------ 3197| 0| p++; 3198| 0| } 3199| 0|# endif 3200| 0| } 3201| | 3202| 0| END_LONG_DOUBLE_ROUNDING (); ------------------ | | 89| 0| SET_FPUCW (oldcw) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3203| 0| } 3204| |# else 3205| | abort (); 3206| |# endif 3207| 0| } 3208| 0| else 3209| 0| { 3210| 0|# if NEED_PRINTF_DIRECTIVE_A || NEED_PRINTF_DOUBLE 3211| 0| double arg = a.arg[dp->arg_index].a.a_double; 3212| | 3213| 0| if (isnand (arg)) ------------------ | | 23| 0|# define isnand(x) __builtin_isnan ((double)(x)) | | ------------------ | | | Branch (23:21): [True: 0, False: 0] | | ------------------ ------------------ 3214| 0| { 3215| 0| if (dp->conversion == 'A') ------------------ | Branch (3215:29): [True: 0, False: 0] ------------------ 3216| 0| { 3217| 0| *p++ = 'N'; *p++ = 'A'; *p++ = 'N'; 3218| 0| } 3219| 0| else 3220| 0| { 3221| 0| *p++ = 'n'; *p++ = 'a'; *p++ = 'n'; 3222| 0| } 3223| 0| } 3224| 0| else 3225| 0| { 3226| 0| int sign = 0; 3227| | 3228| 0| if (signbit (arg)) /* arg < 0.0 or negative zero */ ------------------ | Branch (3228:29): [True: 0, False: 0] ------------------ 3229| 0| { 3230| 0| sign = -1; 3231| 0| arg = -arg; 3232| 0| } 3233| | 3234| 0| if (sign < 0) ------------------ | Branch (3234:29): [True: 0, False: 0] ------------------ 3235| 0| *p++ = '-'; 3236| 0| else if (flags & FLAG_SHOWSIGN) ------------------ | | 35| 0|#define FLAG_SHOWSIGN 4 /* + flag */ ------------------ | Branch (3236:34): [True: 0, False: 0] ------------------ 3237| 0| *p++ = '+'; 3238| 0| else if (flags & FLAG_SPACE) ------------------ | | 36| 0|#define FLAG_SPACE 8 /* space flag */ ------------------ | Branch (3238:34): [True: 0, False: 0] ------------------ 3239| 0| *p++ = ' '; 3240| | 3241| 0| if (arg > 0.0 && arg + arg == arg) ------------------ | Branch (3241:29): [True: 0, False: 0] | Branch (3241:42): [True: 0, False: 0] ------------------ 3242| 0| { 3243| 0| if (dp->conversion == 'A') ------------------ | Branch (3243:33): [True: 0, False: 0] ------------------ 3244| 0| { 3245| 0| *p++ = 'I'; *p++ = 'N'; *p++ = 'F'; 3246| 0| } 3247| 0| else 3248| 0| { 3249| 0| *p++ = 'i'; *p++ = 'n'; *p++ = 'f'; 3250| 0| } 3251| 0| } 3252| 0| else 3253| 0| { 3254| 0| int exponent; 3255| 0| double mantissa; 3256| | 3257| 0| if (arg > 0.0) ------------------ | Branch (3257:33): [True: 0, False: 0] ------------------ 3258| 0| mantissa = printf_frexp (arg, &exponent); 3259| 0| else 3260| 0| { 3261| 0| exponent = 0; 3262| 0| mantissa = 0.0; 3263| 0| } 3264| | 3265| 0| if (has_precision ------------------ | Branch (3265:33): [True: 0, False: 0] ------------------ 3266| 0| && precision < (unsigned int) ((DBL_DIG + 1) * 0.831) + 1) ------------------ | Branch (3266:36): [True: 0, False: 0] ------------------ 3267| 0| { 3268| | /* Round the mantissa. */ 3269| 0| double tail = mantissa; 3270| 0| size_t q; 3271| | 3272| 0| for (q = precision; ; q--) 3273| 0| { 3274| 0| int digit = (int) tail; 3275| 0| tail -= digit; 3276| 0| if (q == 0) ------------------ | Branch (3276:41): [True: 0, False: 0] ------------------ 3277| 0| { 3278| 0| if (digit & 1 ? tail >= 0.5 : tail > 0.5) ------------------ | Branch (3278:45): [True: 0, False: 0] | Branch (3278:45): [True: 0, False: 0] ------------------ 3279| 0| tail = 1 - tail; 3280| 0| else 3281| 0| tail = - tail; 3282| 0| break; 3283| 0| } 3284| 0| tail *= 16.0; 3285| 0| } 3286| 0| if (tail != 0.0) ------------------ | Branch (3286:37): [True: 0, False: 0] ------------------ 3287| 0| for (q = precision; q > 0; q--) ------------------ | Branch (3287:55): [True: 0, False: 0] ------------------ 3288| 0| tail *= 0.0625; 3289| 0| mantissa += tail; 3290| 0| } 3291| | 3292| 0| *p++ = '0'; 3293| 0| *p++ = dp->conversion - 'A' + 'X'; 3294| 0| pad_ptr = p; 3295| 0| { 3296| 0| int digit; 3297| | 3298| 0| digit = (int) mantissa; 3299| 0| mantissa -= digit; 3300| 0| *p++ = '0' + digit; 3301| 0| if ((flags & FLAG_ALT) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3301:35): [True: 0, False: 0] ------------------ 3302| 0| || mantissa > 0.0 || precision > 0) ------------------ | Branch (3302:38): [True: 0, False: 0] | Branch (3302:56): [True: 0, False: 0] ------------------ 3303| 0| { 3304| 0| *p++ = decimal_point_char (); 3305| | /* This loop terminates because we assume 3306| | that FLT_RADIX is a power of 2. */ 3307| 0| while (mantissa > 0.0) ------------------ | Branch (3307:42): [True: 0, False: 0] ------------------ 3308| 0| { 3309| 0| mantissa *= 16.0; 3310| 0| digit = (int) mantissa; 3311| 0| mantissa -= digit; 3312| 0| *p++ = digit 3313| 0| + (digit < 10 ------------------ | Branch (3313:49): [True: 0, False: 0] ------------------ 3314| 0| ? '0' 3315| 0| : dp->conversion - 10); 3316| 0| if (precision > 0) ------------------ | Branch (3316:43): [True: 0, False: 0] ------------------ 3317| 0| precision--; 3318| 0| } 3319| 0| while (precision > 0) ------------------ | Branch (3319:42): [True: 0, False: 0] ------------------ 3320| 0| { 3321| 0| *p++ = '0'; 3322| 0| precision--; 3323| 0| } 3324| 0| } 3325| 0| } 3326| 0| *p++ = dp->conversion - 'A' + 'P'; 3327| |# if WIDE_CHAR_VERSION 3328| | { 3329| | static const wchar_t decimal_format[] = 3330| | { '%', '+', 'd', '\0' }; 3331| | SNPRINTF (p, 6 + 1, decimal_format, exponent); 3332| | } 3333| | while (*p != '\0') 3334| | p++; 3335| |# else 3336| 0| if (sizeof (DCHAR_T) == 1) ------------------ | Branch (3336:35): [True: 0, Folded] ------------------ 3337| 0| { 3338| 0| sprintf ((char *) p, "%+d", exponent); 3339| 0| while (*p != '\0') ------------------ | Branch (3339:42): [True: 0, False: 0] ------------------ 3340| 0| p++; 3341| 0| } 3342| 0| else 3343| 0| { 3344| 0| char expbuf[6 + 1]; 3345| 0| const char *ep; 3346| 0| sprintf (expbuf, "%+d", exponent); 3347| 0| for (ep = expbuf; (*p = *ep) != '\0'; ep++) ------------------ | Branch (3347:53): [True: 0, False: 0] ------------------ 3348| 0| p++; 3349| 0| } 3350| 0|# endif 3351| 0| } 3352| 0| } 3353| |# else 3354| | abort (); 3355| |# endif 3356| 0| } 3357| | 3358| | /* The generated string now extends from tmp to p, with the 3359| | zero padding insertion point being at pad_ptr. */ 3360| 0| count = p - tmp; 3361| | 3362| 0| if (count < width) ------------------ | Branch (3362:21): [True: 0, False: 0] ------------------ 3363| 0| { 3364| 0| size_t pad = width - count; 3365| 0| DCHAR_T *end = p + pad; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 3366| | 3367| 0| if (flags & FLAG_LEFT) ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ | Branch (3367:25): [True: 0, False: 0] ------------------ 3368| 0| { 3369| | /* Pad with spaces on the right. */ 3370| 0| for (; pad > 0; pad--) ------------------ | Branch (3370:32): [True: 0, False: 0] ------------------ 3371| 0| *p++ = ' '; 3372| 0| } 3373| 0| else if ((flags & FLAG_ZERO) && pad_ptr != NULL) ------------------ | | 38| 0|#define FLAG_ZERO 32 ------------------ | Branch (3373:30): [True: 0, False: 0] | Branch (3373:53): [True: 0, False: 0] ------------------ 3374| 0| { 3375| | /* Pad with zeroes. */ 3376| 0| DCHAR_T *q = end; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 3377| | 3378| 0| while (p > pad_ptr) ------------------ | Branch (3378:32): [True: 0, False: 0] ------------------ 3379| 0| *--q = *--p; 3380| 0| for (; pad > 0; pad--) ------------------ | Branch (3380:32): [True: 0, False: 0] ------------------ 3381| 0| *p++ = '0'; 3382| 0| } 3383| 0| else 3384| 0| { 3385| | /* Pad with spaces on the left. */ 3386| 0| DCHAR_T *q = end; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 3387| | 3388| 0| while (p > tmp) ------------------ | Branch (3388:32): [True: 0, False: 0] ------------------ 3389| 0| *--q = *--p; 3390| 0| for (; pad > 0; pad--) ------------------ | Branch (3390:32): [True: 0, False: 0] ------------------ 3391| 0| *p++ = ' '; 3392| 0| } 3393| | 3394| 0| p = end; 3395| 0| } 3396| | 3397| 0| count = p - tmp; 3398| | 3399| 0| if (count >= tmp_length) ------------------ | Branch (3399:21): [True: 0, False: 0] ------------------ 3400| | /* tmp_length was incorrectly calculated - fix the 3401| | code above! */ 3402| 0| abort (); 3403| | 3404| | /* Make room for the result. */ 3405| 0| if (count >= allocated - length) ------------------ | Branch (3405:21): [True: 0, False: 0] ------------------ 3406| 0| { 3407| 0| size_t n = xsum (length, count); 3408| | 3409| 0| ENSURE_ALLOCATION (n); ------------------ | | 1863| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 0, False: 0] | | ------------------ | | 1864| 0| { \ | | 1865| 0| size_t memory_size; \ | | 1866| 0| DCHAR_T *memory; \ | | ------------------ | | | | 147| 0|# define DCHAR_T char | | ------------------ | | 1867| 0| \ | | 1868| 0| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 0, False: 0] | | ------------------ | | 1869| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 0] | | ------------------ | | 1870| 0| allocated = (needed); \ | | 1871| 0| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1872| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1873| 0| goto out_of_memory; \ | | 1874| 0| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 0] | | | Branch (1874:36): [True: 0, False: 0] | | ------------------ | | 1875| 0| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 0| else \ | | 1877| 0| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 1878| 0| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 0] | | ------------------ | | 1879| 0| goto out_of_memory; \ | | 1880| 0| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 0] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 0| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 0| result = memory; \ | | 1883| 0| } ------------------ 3410| 0| } 3411| | 3412| | /* Append the result. */ 3413| 0| memcpy (result + length, tmp, count * sizeof (DCHAR_T)); 3414| 0| if (tmp != tmpbuf) ------------------ | Branch (3414:21): [True: 0, False: 0] ------------------ 3415| 0| free (tmp); ------------------ | | 35| 0|#define free g_free ------------------ 3416| 0| length += count; 3417| 0| } 3418| 484k|#endif 3419| 484k|#if (NEED_PRINTF_INFINITE_DOUBLE || NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE || NEED_PRINTF_LONG_DOUBLE) && !defined IN_LIBINTL 3420| 484k| else if ((dp->conversion == 'f' || dp->conversion == 'F' ------------------ | Branch (3420:23): [True: 0, False: 484k] | Branch (3420:48): [True: 0, False: 484k] ------------------ 3421| 484k| || dp->conversion == 'e' || dp->conversion == 'E' ------------------ | Branch (3421:26): [True: 0, False: 484k] | Branch (3421:51): [True: 0, False: 484k] ------------------ 3422| 484k| || dp->conversion == 'g' || dp->conversion == 'G' ------------------ | Branch (3422:26): [True: 0, False: 484k] | Branch (3422:51): [True: 0, False: 484k] ------------------ 3423| 484k| || dp->conversion == 'a' || dp->conversion == 'A') ------------------ | Branch (3423:26): [True: 0, False: 484k] | Branch (3423:51): [True: 0, False: 484k] ------------------ 3424| 0| && (0 ------------------ | Branch (3424:26): [Folded, False: 0] ------------------ 3425| 0|# if NEED_PRINTF_DOUBLE 3426| 0| || a.arg[dp->arg_index].type == TYPE_DOUBLE ------------------ | Branch (3426:29): [True: 0, False: 0] ------------------ 3427| |# elif NEED_PRINTF_INFINITE_DOUBLE 3428| | || (a.arg[dp->arg_index].type == TYPE_DOUBLE 3429| | /* The systems (mingw) which produce wrong output 3430| | for Inf, -Inf, and NaN also do so for -0.0. 3431| | Therefore we treat this case here as well. */ 3432| | && is_infinite_or_zero (a.arg[dp->arg_index].a.a_double)) 3433| |# endif 3434| 0|# if NEED_PRINTF_LONG_DOUBLE 3435| 0| || a.arg[dp->arg_index].type == TYPE_LONGDOUBLE ------------------ | Branch (3435:29): [True: 0, False: 0] ------------------ 3436| |# elif NEED_PRINTF_INFINITE_LONG_DOUBLE 3437| | || (a.arg[dp->arg_index].type == TYPE_LONGDOUBLE 3438| | /* Some systems produce wrong output for Inf, 3439| | -Inf, and NaN. Some systems in this category 3440| | (IRIX 5.3) also do so for -0.0. Therefore we 3441| | treat this case here as well. */ 3442| | && is_infinite_or_zerol (a.arg[dp->arg_index].a.a_longdouble)) 3443| |# endif 3444| 0| )) 3445| 0| { 3446| 0|# if (NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE) && (NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE) 3447| 0| arg_type type = a.arg[dp->arg_index].type; 3448| 0|# endif 3449| 0| int flags = dp->flags; 3450| 0| size_t width; 3451| 0| size_t count; 3452| 0| int has_precision; 3453| 0| size_t precision; 3454| 0| size_t tmp_length; 3455| 0| DCHAR_T tmpbuf[700]; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 3456| 0| DCHAR_T *tmp; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 3457| 0| DCHAR_T *pad_ptr; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 3458| 0| DCHAR_T *p; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 3459| | 3460| 0| width = 0; 3461| 0| if (dp->width_start != dp->width_end) ------------------ | Branch (3461:21): [True: 0, False: 0] ------------------ 3462| 0| { 3463| 0| if (dp->width_arg_index != ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (3463:25): [True: 0, False: 0] ------------------ 3464| 0| { 3465| 0| int arg; 3466| | 3467| 0| if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) ------------------ | Branch (3467:29): [True: 0, False: 0] ------------------ 3468| 0| abort (); 3469| 0| arg = a.arg[dp->width_arg_index].a.a_int; 3470| 0| width = arg; 3471| 0| if (arg < 0) ------------------ | Branch (3471:29): [True: 0, False: 0] ------------------ 3472| 0| { 3473| | /* "A negative field width is taken as a '-' flag 3474| | followed by a positive field width." */ 3475| 0| flags |= FLAG_LEFT; ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ 3476| 0| width = -width; 3477| 0| } 3478| 0| } 3479| 0| else 3480| 0| { 3481| 0| const FCHAR_T *digitp = dp->width_start; 3482| | 3483| 0| do 3484| 0| width = xsum (xtimes (width, 10), *digitp++ - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 3485| 0| while (digitp != dp->width_end); ------------------ | Branch (3485:32): [True: 0, False: 0] ------------------ 3486| 0| } 3487| 0| } 3488| | 3489| 0| has_precision = 0; 3490| 0| precision = 0; 3491| 0| if (dp->precision_start != dp->precision_end) ------------------ | Branch (3491:21): [True: 0, False: 0] ------------------ 3492| 0| { 3493| 0| if (dp->precision_arg_index != ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (3493:25): [True: 0, False: 0] ------------------ 3494| 0| { 3495| 0| int arg; 3496| | 3497| 0| if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) ------------------ | Branch (3497:29): [True: 0, False: 0] ------------------ 3498| 0| abort (); 3499| 0| arg = a.arg[dp->precision_arg_index].a.a_int; 3500| | /* "A negative precision is taken as if the precision 3501| | were omitted." */ 3502| 0| if (arg >= 0) ------------------ | Branch (3502:29): [True: 0, False: 0] ------------------ 3503| 0| { 3504| 0| precision = arg; 3505| 0| has_precision = 1; 3506| 0| } 3507| 0| } 3508| 0| else 3509| 0| { 3510| 0| const FCHAR_T *digitp = dp->precision_start + 1; 3511| | 3512| 0| precision = 0; 3513| 0| while (digitp != dp->precision_end) ------------------ | Branch (3513:32): [True: 0, False: 0] ------------------ 3514| 0| precision = xsum (xtimes (precision, 10), *digitp++ - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 3515| 0| has_precision = 1; 3516| 0| } 3517| 0| } 3518| | 3519| | /* POSIX specifies the default precision to be 6 for %f, %F, 3520| | %e, %E, but not for %g, %G. Implementations appear to use 3521| | the same default precision also for %g, %G. But for %a, %A, 3522| | the default precision is 0. */ 3523| 0| if (!has_precision) ------------------ | Branch (3523:21): [True: 0, False: 0] ------------------ 3524| 0| if (!(dp->conversion == 'a' || dp->conversion == 'A')) ------------------ | Branch (3524:25): [True: 0, False: 0] | Branch (3524:50): [True: 0, False: 0] ------------------ 3525| 0| precision = 6; 3526| | 3527| | /* Allocate a temporary buffer of sufficient size. */ 3528| 0|# if NEED_PRINTF_DOUBLE && NEED_PRINTF_LONG_DOUBLE 3529| 0| tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : DBL_DIG + 1); ------------------ | Branch (3529:31): [True: 0, False: 0] ------------------ 3530| |# elif NEED_PRINTF_INFINITE_DOUBLE && NEED_PRINTF_LONG_DOUBLE 3531| | tmp_length = (type == TYPE_LONGDOUBLE ? LDBL_DIG + 1 : 0); 3532| |# elif NEED_PRINTF_LONG_DOUBLE 3533| | tmp_length = LDBL_DIG + 1; 3534| |# elif NEED_PRINTF_DOUBLE 3535| | tmp_length = DBL_DIG + 1; 3536| |# else 3537| | tmp_length = 0; 3538| |# endif 3539| 0| if (tmp_length < precision) ------------------ | Branch (3539:21): [True: 0, False: 0] ------------------ 3540| 0| tmp_length = precision; 3541| 0|# if NEED_PRINTF_LONG_DOUBLE 3542| 0|# if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE 3543| 0| if (type == TYPE_LONGDOUBLE) ------------------ | Branch (3543:21): [True: 0, False: 0] ------------------ 3544| 0|# endif 3545| 0| if (dp->conversion == 'f' || dp->conversion == 'F') ------------------ | Branch (3545:23): [True: 0, False: 0] | Branch (3545:48): [True: 0, False: 0] ------------------ 3546| 0| { 3547| 0| long double arg = a.arg[dp->arg_index].a.a_longdouble; 3548| 0| if (!(isnanl (arg) || arg + arg == arg)) ------------------ | | 31| 0|# define isnanl rpl_isnanl ------------------ | Branch (3548:29): [True: 0, False: 0] | Branch (3548:45): [True: 0, False: 0] ------------------ 3549| 0| { 3550| | /* arg is finite and nonzero. */ 3551| 0| int exponent = floorlog10l (arg < 0 ? -arg : arg); ------------------ | Branch (3551:55): [True: 0, False: 0] ------------------ 3552| 0| if (exponent >= 0 && tmp_length < exponent + precision) ------------------ | Branch (3552:31): [True: 0, False: 0] | Branch (3552:48): [True: 0, False: 0] ------------------ 3553| 0| tmp_length = exponent + precision; 3554| 0| } 3555| 0| } 3556| 0|# endif 3557| 0|# if NEED_PRINTF_DOUBLE 3558| 0|# if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE 3559| 0| if (type == TYPE_DOUBLE) ------------------ | Branch (3559:21): [True: 0, False: 0] ------------------ 3560| 0|# endif 3561| 0| if (dp->conversion == 'f' || dp->conversion == 'F') ------------------ | Branch (3561:23): [True: 0, False: 0] | Branch (3561:48): [True: 0, False: 0] ------------------ 3562| 0| { 3563| 0| double arg = a.arg[dp->arg_index].a.a_double; 3564| 0| if (!(isnand (arg) || arg + arg == arg)) ------------------ | | 23| 0|# define isnand(x) __builtin_isnan ((double)(x)) | | ------------------ | | | Branch (23:21): [True: 0, False: 0] | | ------------------ ------------------ | Branch (3564:45): [True: 0, False: 0] ------------------ 3565| 0| { 3566| | /* arg is finite and nonzero. */ 3567| 0| int exponent = floorlog10 (arg < 0 ? -arg : arg); ------------------ | Branch (3567:54): [True: 0, False: 0] ------------------ 3568| 0| if (exponent >= 0 && tmp_length < exponent + precision) ------------------ | Branch (3568:31): [True: 0, False: 0] | Branch (3568:48): [True: 0, False: 0] ------------------ 3569| 0| tmp_length = exponent + precision; 3570| 0| } 3571| 0| } 3572| 0|# endif 3573| | /* Account for sign, decimal point etc. */ 3574| 0| tmp_length = xsum (tmp_length, 12); 3575| | 3576| 0| if (tmp_length < width) ------------------ | Branch (3576:21): [True: 0, False: 0] ------------------ 3577| 0| tmp_length = width; 3578| | 3579| 0| tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */ 3580| | 3581| 0| if (tmp_length <= sizeof (tmpbuf) / sizeof (DCHAR_T)) ------------------ | Branch (3581:21): [True: 0, False: 0] ------------------ 3582| 0| tmp = tmpbuf; 3583| 0| else 3584| 0| { 3585| 0| size_t tmp_memsize = xtimes (tmp_length, sizeof (DCHAR_T)); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 3586| | 3587| 0| if (size_overflow_p (tmp_memsize)) ------------------ | | 112| 0| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 0] | | ------------------ ------------------ 3588| | /* Overflow, would lead to out of memory. */ 3589| 0| goto out_of_memory; 3590| 0| tmp = (DCHAR_T *) malloc (tmp_memsize); ------------------ | | 33| 0|#define malloc g_malloc ------------------ 3591| 0| if (tmp == NULL) ------------------ | Branch (3591:25): [True: 0, False: 0] ------------------ 3592| | /* Out of memory. */ 3593| 0| goto out_of_memory; 3594| 0| } 3595| | 3596| 0| pad_ptr = NULL; 3597| 0| p = tmp; 3598| | 3599| 0|# if NEED_PRINTF_LONG_DOUBLE || NEED_PRINTF_INFINITE_LONG_DOUBLE 3600| 0|# if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE 3601| 0| if (type == TYPE_LONGDOUBLE) ------------------ | Branch (3601:21): [True: 0, False: 0] ------------------ 3602| 0|# endif 3603| 0| { 3604| 0| long double arg = a.arg[dp->arg_index].a.a_longdouble; 3605| | 3606| 0| if (isnanl (arg)) ------------------ | | 31| 0|# define isnanl rpl_isnanl ------------------ | Branch (3606:25): [True: 0, False: 0] ------------------ 3607| 0| { 3608| 0| if (dp->conversion >= 'A' && dp->conversion <= 'Z') ------------------ | Branch (3608:29): [True: 0, False: 0] | Branch (3608:54): [True: 0, False: 0] ------------------ 3609| 0| { 3610| 0| *p++ = 'N'; *p++ = 'A'; *p++ = 'N'; 3611| 0| } 3612| 0| else 3613| 0| { 3614| 0| *p++ = 'n'; *p++ = 'a'; *p++ = 'n'; 3615| 0| } 3616| 0| } 3617| 0| else 3618| 0| { 3619| 0| int sign = 0; 3620| 0| DECL_LONG_DOUBLE_ROUNDING ------------------ | | 84| 0| fpucw_t oldcw; ------------------ 3621| | 3622| 0| BEGIN_LONG_DOUBLE_ROUNDING (); ------------------ | | 86| 0| (void)(oldcw = GET_FPUCW (), \ | | ------------------ | | | | 74| 0| ({ fpucw_t _cw; \ | | | | 75| 0| __asm__ __volatile__ ("fnstcw %0" : "=m" (*&_cw)); \ | | | | 76| 0| _cw; \ | | | | 77| 0| }) | | ------------------ | | 87| 0| SET_FPUCW ((oldcw & ~FPU_PC_MASK) | FPU_PC_EXTENDED)) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3623| | 3624| 0| if (signbit (arg)) /* arg < 0.0L or negative zero */ ------------------ | Branch (3624:29): [True: 0, False: 0] ------------------ 3625| 0| { 3626| 0| sign = -1; 3627| 0| arg = -arg; 3628| 0| } 3629| | 3630| 0| if (sign < 0) ------------------ | Branch (3630:29): [True: 0, False: 0] ------------------ 3631| 0| *p++ = '-'; 3632| 0| else if (flags & FLAG_SHOWSIGN) ------------------ | | 35| 0|#define FLAG_SHOWSIGN 4 /* + flag */ ------------------ | Branch (3632:34): [True: 0, False: 0] ------------------ 3633| 0| *p++ = '+'; 3634| 0| else if (flags & FLAG_SPACE) ------------------ | | 36| 0|#define FLAG_SPACE 8 /* space flag */ ------------------ | Branch (3634:34): [True: 0, False: 0] ------------------ 3635| 0| *p++ = ' '; 3636| | 3637| 0| if (arg > 0.0L && arg + arg == arg) ------------------ | Branch (3637:29): [True: 0, False: 0] | Branch (3637:43): [True: 0, False: 0] ------------------ 3638| 0| { 3639| 0| if (dp->conversion >= 'A' && dp->conversion <= 'Z') ------------------ | Branch (3639:33): [True: 0, False: 0] | Branch (3639:58): [True: 0, False: 0] ------------------ 3640| 0| { 3641| 0| *p++ = 'I'; *p++ = 'N'; *p++ = 'F'; 3642| 0| } 3643| 0| else 3644| 0| { 3645| 0| *p++ = 'i'; *p++ = 'n'; *p++ = 'f'; 3646| 0| } 3647| 0| } 3648| 0| else 3649| 0| { 3650| 0|# if NEED_PRINTF_LONG_DOUBLE 3651| 0| pad_ptr = p; 3652| | 3653| 0| if (dp->conversion == 'f' || dp->conversion == 'F') ------------------ | Branch (3653:33): [True: 0, False: 0] | Branch (3653:58): [True: 0, False: 0] ------------------ 3654| 0| { 3655| 0| char *digits; 3656| 0| size_t ndigits; 3657| | 3658| 0| digits = 3659| 0| scale10_round_decimal_long_double (arg, precision); 3660| 0| if (digits == NULL) ------------------ | Branch (3660:37): [True: 0, False: 0] ------------------ 3661| 0| { 3662| 0| END_LONG_DOUBLE_ROUNDING (); ------------------ | | 89| 0| SET_FPUCW (oldcw) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3663| 0| goto out_of_memory; 3664| 0| } 3665| 0| ndigits = strlen (digits); 3666| | 3667| 0| if (ndigits > precision) ------------------ | Branch (3667:37): [True: 0, False: 0] ------------------ 3668| 0| do 3669| 0| { 3670| 0| --ndigits; 3671| 0| *p++ = digits[ndigits]; 3672| 0| } 3673| 0| while (ndigits > precision); ------------------ | Branch (3673:42): [True: 0, False: 0] ------------------ 3674| 0| else 3675| 0| *p++ = '0'; 3676| | /* Here ndigits <= precision. */ 3677| 0| if ((flags & FLAG_ALT) || precision > 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3677:37): [True: 0, False: 0] | Branch (3677:59): [True: 0, False: 0] ------------------ 3678| 0| { 3679| 0| *p++ = decimal_point_char (); 3680| 0| for (; precision > ndigits; precision--) ------------------ | Branch (3680:44): [True: 0, False: 0] ------------------ 3681| 0| *p++ = '0'; 3682| 0| while (ndigits > 0) ------------------ | Branch (3682:44): [True: 0, False: 0] ------------------ 3683| 0| { 3684| 0| --ndigits; 3685| 0| *p++ = digits[ndigits]; 3686| 0| } 3687| 0| } 3688| | 3689| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3690| 0| } 3691| 0| else if (dp->conversion == 'e' || dp->conversion == 'E') ------------------ | Branch (3691:38): [True: 0, False: 0] | Branch (3691:63): [True: 0, False: 0] ------------------ 3692| 0| { 3693| 0| int exponent; 3694| | 3695| 0| if (arg == 0.0L) ------------------ | Branch (3695:37): [True: 0, False: 0] ------------------ 3696| 0| { 3697| 0| exponent = 0; 3698| 0| *p++ = '0'; 3699| 0| if ((flags & FLAG_ALT) || precision > 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3699:41): [True: 0, False: 0] | Branch (3699:63): [True: 0, False: 0] ------------------ 3700| 0| { 3701| 0| *p++ = decimal_point_char (); 3702| 0| for (; precision > 0; precision--) ------------------ | Branch (3702:48): [True: 0, False: 0] ------------------ 3703| 0| *p++ = '0'; 3704| 0| } 3705| 0| } 3706| 0| else 3707| 0| { 3708| | /* arg > 0.0L. */ 3709| 0| int adjusted; 3710| 0| char *digits; 3711| 0| size_t ndigits; 3712| | 3713| 0| exponent = floorlog10l (arg); 3714| 0| adjusted = 0; 3715| 0| for (;;) 3716| 0| { 3717| 0| digits = 3718| 0| scale10_round_decimal_long_double (arg, 3719| 0| (int)precision - exponent); 3720| 0| if (digits == NULL) ------------------ | Branch (3720:45): [True: 0, False: 0] ------------------ 3721| 0| { 3722| 0| END_LONG_DOUBLE_ROUNDING (); ------------------ | | 89| 0| SET_FPUCW (oldcw) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3723| 0| goto out_of_memory; 3724| 0| } 3725| 0| ndigits = strlen (digits); 3726| | 3727| 0| if (ndigits == precision + 1) ------------------ | Branch (3727:45): [True: 0, False: 0] ------------------ 3728| 0| break; 3729| 0| if (ndigits < precision ------------------ | Branch (3729:45): [True: 0, False: 0] ------------------ 3730| 0| || ndigits > precision + 2) ------------------ | Branch (3730:48): [True: 0, False: 0] ------------------ 3731| | /* The exponent was not guessed 3732| | precisely enough. */ 3733| 0| abort (); 3734| 0| if (adjusted) ------------------ | Branch (3734:45): [True: 0, False: 0] ------------------ 3735| | /* None of two values of exponent is 3736| | the right one. Prevent an endless 3737| | loop. */ 3738| 0| abort (); 3739| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3740| 0| if (ndigits == precision) ------------------ | Branch (3740:45): [True: 0, False: 0] ------------------ 3741| 0| exponent -= 1; 3742| 0| else 3743| 0| exponent += 1; 3744| 0| adjusted = 1; 3745| 0| } 3746| | /* Here ndigits = precision+1. */ 3747| 0| if (is_borderline (digits, precision)) ------------------ | Branch (3747:41): [True: 0, False: 0] ------------------ 3748| 0| { 3749| | /* Maybe the exponent guess was too high 3750| | and a smaller exponent can be reached 3751| | by turning a 10...0 into 9...9x. */ 3752| 0| char *digits2 = 3753| 0| scale10_round_decimal_long_double (arg, 3754| 0| (int)precision - exponent + 1); 3755| 0| if (digits2 == NULL) ------------------ | Branch (3755:45): [True: 0, False: 0] ------------------ 3756| 0| { 3757| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3758| 0| END_LONG_DOUBLE_ROUNDING (); ------------------ | | 89| 0| SET_FPUCW (oldcw) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3759| 0| goto out_of_memory; 3760| 0| } 3761| 0| if (strlen (digits2) == precision + 1) ------------------ | Branch (3761:45): [True: 0, False: 0] ------------------ 3762| 0| { 3763| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3764| 0| digits = digits2; 3765| 0| exponent -= 1; 3766| 0| } 3767| 0| else 3768| 0| free (digits2); ------------------ | | 35| 0|#define free g_free ------------------ 3769| 0| } 3770| | /* Here ndigits = precision+1. */ 3771| | 3772| 0| *p++ = digits[--ndigits]; 3773| 0| if ((flags & FLAG_ALT) || precision > 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3773:41): [True: 0, False: 0] | Branch (3773:63): [True: 0, False: 0] ------------------ 3774| 0| { 3775| 0| *p++ = decimal_point_char (); 3776| 0| while (ndigits > 0) ------------------ | Branch (3776:48): [True: 0, False: 0] ------------------ 3777| 0| { 3778| 0| --ndigits; 3779| 0| *p++ = digits[ndigits]; 3780| 0| } 3781| 0| } 3782| | 3783| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3784| 0| } 3785| | 3786| 0| *p++ = dp->conversion; /* 'e' or 'E' */ 3787| |# if WIDE_CHAR_VERSION 3788| | { 3789| | static const wchar_t decimal_format[] = 3790| | { '%', '+', '.', '2', 'd', '\0' }; 3791| | SNPRINTF (p, 6 + 1, decimal_format, exponent); 3792| | } 3793| | while (*p != '\0') 3794| | p++; 3795| |# else 3796| 0| if (sizeof (DCHAR_T) == 1) ------------------ | Branch (3796:37): [True: 0, Folded] ------------------ 3797| 0| { 3798| 0| sprintf ((char *) p, "%+.2d", exponent); 3799| 0| while (*p != '\0') ------------------ | Branch (3799:44): [True: 0, False: 0] ------------------ 3800| 0| p++; 3801| 0| } 3802| 0| else 3803| 0| { 3804| 0| char expbuf[6 + 1]; 3805| 0| const char *ep; 3806| 0| sprintf (expbuf, "%+.2d", exponent); 3807| 0| for (ep = expbuf; (*p = *ep) != '\0'; ep++) ------------------ | Branch (3807:55): [True: 0, False: 0] ------------------ 3808| 0| p++; 3809| 0| } 3810| 0|# endif 3811| 0| } 3812| 0| else if (dp->conversion == 'g' || dp->conversion == 'G') ------------------ | Branch (3812:38): [True: 0, False: 0] | Branch (3812:63): [True: 0, False: 0] ------------------ 3813| 0| { 3814| 0| if (precision == 0) ------------------ | Branch (3814:37): [True: 0, False: 0] ------------------ 3815| 0| precision = 1; 3816| | /* precision >= 1. */ 3817| | 3818| 0| if (arg == 0.0L) ------------------ | Branch (3818:37): [True: 0, False: 0] ------------------ 3819| | /* The exponent is 0, >= -4, < precision. 3820| | Use fixed-point notation. */ 3821| 0| { 3822| 0| size_t ndigits = precision; 3823| | /* Number of trailing zeroes that have to be 3824| | dropped. */ 3825| 0| size_t nzeroes = 3826| 0| (flags & FLAG_ALT ? 0 : precision - 1); ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3826:40): [True: 0, False: 0] ------------------ 3827| | 3828| 0| --ndigits; 3829| 0| *p++ = '0'; 3830| 0| if ((flags & FLAG_ALT) || ndigits > nzeroes) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3830:41): [True: 0, False: 0] | Branch (3830:63): [True: 0, False: 0] ------------------ 3831| 0| { 3832| 0| *p++ = decimal_point_char (); 3833| 0| while (ndigits > nzeroes) ------------------ | Branch (3833:48): [True: 0, False: 0] ------------------ 3834| 0| { 3835| 0| --ndigits; 3836| 0| *p++ = '0'; 3837| 0| } 3838| 0| } 3839| 0| } 3840| 0| else 3841| 0| { 3842| | /* arg > 0.0L. */ 3843| 0| int exponent; 3844| 0| int adjusted; 3845| 0| char *digits; 3846| 0| size_t ndigits; 3847| 0| size_t nzeroes; 3848| | 3849| 0| exponent = floorlog10l (arg); 3850| 0| adjusted = 0; 3851| 0| for (;;) 3852| 0| { 3853| 0| digits = 3854| 0| scale10_round_decimal_long_double (arg, 3855| 0| (int)(precision - 1) - exponent); 3856| 0| if (digits == NULL) ------------------ | Branch (3856:45): [True: 0, False: 0] ------------------ 3857| 0| { 3858| 0| END_LONG_DOUBLE_ROUNDING (); ------------------ | | 89| 0| SET_FPUCW (oldcw) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3859| 0| goto out_of_memory; 3860| 0| } 3861| 0| ndigits = strlen (digits); 3862| | 3863| 0| if (ndigits == precision) ------------------ | Branch (3863:45): [True: 0, False: 0] ------------------ 3864| 0| break; 3865| 0| if (ndigits < precision - 1 ------------------ | Branch (3865:45): [True: 0, False: 0] ------------------ 3866| 0| || ndigits > precision + 1) ------------------ | Branch (3866:48): [True: 0, False: 0] ------------------ 3867| | /* The exponent was not guessed 3868| | precisely enough. */ 3869| 0| abort (); 3870| 0| if (adjusted) ------------------ | Branch (3870:45): [True: 0, False: 0] ------------------ 3871| | /* None of two values of exponent is 3872| | the right one. Prevent an endless 3873| | loop. */ 3874| 0| abort (); 3875| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3876| 0| if (ndigits < precision) ------------------ | Branch (3876:45): [True: 0, False: 0] ------------------ 3877| 0| exponent -= 1; 3878| 0| else 3879| 0| exponent += 1; 3880| 0| adjusted = 1; 3881| 0| } 3882| | /* Here ndigits = precision. */ 3883| 0| if (is_borderline (digits, precision - 1)) ------------------ | Branch (3883:41): [True: 0, False: 0] ------------------ 3884| 0| { 3885| | /* Maybe the exponent guess was too high 3886| | and a smaller exponent can be reached 3887| | by turning a 10...0 into 9...9x. */ 3888| 0| char *digits2 = 3889| 0| scale10_round_decimal_long_double (arg, 3890| 0| (int)(precision - 1) - exponent + 1); 3891| 0| if (digits2 == NULL) ------------------ | Branch (3891:45): [True: 0, False: 0] ------------------ 3892| 0| { 3893| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3894| 0| END_LONG_DOUBLE_ROUNDING (); ------------------ | | 89| 0| SET_FPUCW (oldcw) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 3895| 0| goto out_of_memory; 3896| 0| } 3897| 0| if (strlen (digits2) == precision) ------------------ | Branch (3897:45): [True: 0, False: 0] ------------------ 3898| 0| { 3899| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3900| 0| digits = digits2; 3901| 0| exponent -= 1; 3902| 0| } 3903| 0| else 3904| 0| free (digits2); ------------------ | | 35| 0|#define free g_free ------------------ 3905| 0| } 3906| | /* Here ndigits = precision. */ 3907| | 3908| | /* Determine the number of trailing zeroes 3909| | that have to be dropped. */ 3910| 0| nzeroes = 0; 3911| 0| if ((flags & FLAG_ALT) == 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3911:41): [True: 0, False: 0] ------------------ 3912| 0| while (nzeroes < ndigits ------------------ | Branch (3912:46): [True: 0, False: 0] ------------------ 3913| 0| && digits[nzeroes] == '0') ------------------ | Branch (3913:49): [True: 0, False: 0] ------------------ 3914| 0| nzeroes++; 3915| | 3916| | /* The exponent is now determined. */ 3917| 0| if (exponent >= -4 ------------------ | Branch (3917:41): [True: 0, False: 0] ------------------ 3918| 0| && exponent < (long)precision) ------------------ | Branch (3918:44): [True: 0, False: 0] ------------------ 3919| 0| { 3920| | /* Fixed-point notation: 3921| | max(exponent,0)+1 digits, then the 3922| | decimal point, then the remaining 3923| | digits without trailing zeroes. */ 3924| 0| if (exponent >= 0) ------------------ | Branch (3924:45): [True: 0, False: 0] ------------------ 3925| 0| { 3926| 0| size_t ecount = exponent + 1; 3927| | /* Note: count <= precision = ndigits. */ 3928| 0| for (; ecount > 0; ecount--) ------------------ | Branch (3928:52): [True: 0, False: 0] ------------------ 3929| 0| *p++ = digits[--ndigits]; 3930| 0| if ((flags & FLAG_ALT) || ndigits > nzeroes) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3930:49): [True: 0, False: 0] | Branch (3930:71): [True: 0, False: 0] ------------------ 3931| 0| { 3932| 0| *p++ = decimal_point_char (); 3933| 0| while (ndigits > nzeroes) ------------------ | Branch (3933:56): [True: 0, False: 0] ------------------ 3934| 0| { 3935| 0| --ndigits; 3936| 0| *p++ = digits[ndigits]; 3937| 0| } 3938| 0| } 3939| 0| } 3940| 0| else 3941| 0| { 3942| 0| size_t ecount = -exponent - 1; 3943| 0| *p++ = '0'; 3944| 0| *p++ = decimal_point_char (); 3945| 0| for (; ecount > 0; ecount--) ------------------ | Branch (3945:52): [True: 0, False: 0] ------------------ 3946| 0| *p++ = '0'; 3947| 0| while (ndigits > nzeroes) ------------------ | Branch (3947:52): [True: 0, False: 0] ------------------ 3948| 0| { 3949| 0| --ndigits; 3950| 0| *p++ = digits[ndigits]; 3951| 0| } 3952| 0| } 3953| 0| } 3954| 0| else 3955| 0| { 3956| | /* Exponential notation. */ 3957| 0| *p++ = digits[--ndigits]; 3958| 0| if ((flags & FLAG_ALT) || ndigits > nzeroes) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (3958:45): [True: 0, False: 0] | Branch (3958:67): [True: 0, False: 0] ------------------ 3959| 0| { 3960| 0| *p++ = decimal_point_char (); 3961| 0| while (ndigits > nzeroes) ------------------ | Branch (3961:52): [True: 0, False: 0] ------------------ 3962| 0| { 3963| 0| --ndigits; 3964| 0| *p++ = digits[ndigits]; 3965| 0| } 3966| 0| } 3967| 0| *p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */ 3968| |# if WIDE_CHAR_VERSION 3969| | { 3970| | static const wchar_t decimal_format[] = 3971| | { '%', '+', '.', '2', 'd', '\0' }; 3972| | SNPRINTF (p, 6 + 1, decimal_format, exponent); 3973| | } 3974| | while (*p != '\0') 3975| | p++; 3976| |# else 3977| 0| if (sizeof (DCHAR_T) == 1) ------------------ | Branch (3977:45): [True: 0, Folded] ------------------ 3978| 0| { 3979| 0| sprintf ((char *) p, "%+.2d", exponent); 3980| 0| while (*p != '\0') ------------------ | Branch (3980:52): [True: 0, False: 0] ------------------ 3981| 0| p++; 3982| 0| } 3983| 0| else 3984| 0| { 3985| 0| char expbuf[6 + 1]; 3986| 0| const char *ep; 3987| 0| sprintf (expbuf, "%+.2d", exponent); 3988| 0| for (ep = expbuf; (*p = *ep) != '\0'; ep++) ------------------ | Branch (3988:63): [True: 0, False: 0] ------------------ 3989| 0| p++; 3990| 0| } 3991| 0|# endif 3992| 0| } 3993| | 3994| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 3995| 0| } 3996| 0| } 3997| 0| else 3998| 0| abort (); 3999| |# else 4000| | /* arg is finite. */ 4001| | if (!(arg == 0.0L)) 4002| | abort (); 4003| | 4004| | pad_ptr = p; 4005| | 4006| | if (dp->conversion == 'f' || dp->conversion == 'F') 4007| | { 4008| | *p++ = '0'; 4009| | if ((flags & FLAG_ALT) || precision > 0) 4010| | { 4011| | *p++ = decimal_point_char (); 4012| | for (; precision > 0; precision--) 4013| | *p++ = '0'; 4014| | } 4015| | } 4016| | else if (dp->conversion == 'e' || dp->conversion == 'E') 4017| | { 4018| | *p++ = '0'; 4019| | if ((flags & FLAG_ALT) || precision > 0) 4020| | { 4021| | *p++ = decimal_point_char (); 4022| | for (; precision > 0; precision--) 4023| | *p++ = '0'; 4024| | } 4025| | *p++ = dp->conversion; /* 'e' or 'E' */ 4026| | *p++ = '+'; 4027| | *p++ = '0'; 4028| | *p++ = '0'; 4029| | } 4030| | else if (dp->conversion == 'g' || dp->conversion == 'G') 4031| | { 4032| | *p++ = '0'; 4033| | if (flags & FLAG_ALT) 4034| | { 4035| | size_t ndigits = 4036| | (precision > 0 ? precision - 1 : 0); 4037| | *p++ = decimal_point_char (); 4038| | for (; ndigits > 0; --ndigits) 4039| | *p++ = '0'; 4040| | } 4041| | } 4042| | else if (dp->conversion == 'a' || dp->conversion == 'A') 4043| | { 4044| | *p++ = '0'; 4045| | *p++ = dp->conversion - 'A' + 'X'; 4046| | pad_ptr = p; 4047| | *p++ = '0'; 4048| | if ((flags & FLAG_ALT) || precision > 0) 4049| | { 4050| | *p++ = decimal_point_char (); 4051| | for (; precision > 0; precision--) 4052| | *p++ = '0'; 4053| | } 4054| | *p++ = dp->conversion - 'A' + 'P'; 4055| | *p++ = '+'; 4056| | *p++ = '0'; 4057| | } 4058| | else 4059| | abort (); 4060| |# endif 4061| 0| } 4062| | 4063| 0| END_LONG_DOUBLE_ROUNDING (); ------------------ | | 89| 0| SET_FPUCW (oldcw) | | ------------------ | | | | 79| 0| (void)({ fpucw_t _ncw = (word); \ | | | | 80| 0| __asm__ __volatile__ ("fldcw %0" : : "m" (*&_ncw)); \ | | | | 81| 0| }) | | ------------------ ------------------ 4064| 0| } 4065| 0| } 4066| 0|# if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE 4067| 0| else 4068| 0|# endif 4069| 0|# endif 4070| 0|# if NEED_PRINTF_DOUBLE || NEED_PRINTF_INFINITE_DOUBLE 4071| 0| { 4072| 0| double arg = a.arg[dp->arg_index].a.a_double; 4073| | 4074| 0| if (isnand (arg)) ------------------ | | 23| 0|# define isnand(x) __builtin_isnan ((double)(x)) | | ------------------ | | | Branch (23:21): [True: 0, False: 0] | | ------------------ ------------------ 4075| 0| { 4076| 0| if (dp->conversion >= 'A' && dp->conversion <= 'Z') ------------------ | Branch (4076:29): [True: 0, False: 0] | Branch (4076:54): [True: 0, False: 0] ------------------ 4077| 0| { 4078| 0| *p++ = 'N'; *p++ = 'A'; *p++ = 'N'; 4079| 0| } 4080| 0| else 4081| 0| { 4082| 0| *p++ = 'n'; *p++ = 'a'; *p++ = 'n'; 4083| 0| } 4084| 0| } 4085| 0| else 4086| 0| { 4087| 0| int sign = 0; 4088| | 4089| 0| if (signbit (arg)) /* arg < 0.0 or negative zero */ ------------------ | Branch (4089:29): [True: 0, False: 0] ------------------ 4090| 0| { 4091| 0| sign = -1; 4092| 0| arg = -arg; 4093| 0| } 4094| | 4095| 0| if (sign < 0) ------------------ | Branch (4095:29): [True: 0, False: 0] ------------------ 4096| 0| *p++ = '-'; 4097| 0| else if (flags & FLAG_SHOWSIGN) ------------------ | | 35| 0|#define FLAG_SHOWSIGN 4 /* + flag */ ------------------ | Branch (4097:34): [True: 0, False: 0] ------------------ 4098| 0| *p++ = '+'; 4099| 0| else if (flags & FLAG_SPACE) ------------------ | | 36| 0|#define FLAG_SPACE 8 /* space flag */ ------------------ | Branch (4099:34): [True: 0, False: 0] ------------------ 4100| 0| *p++ = ' '; 4101| | 4102| 0| if (arg > 0.0 && arg + arg == arg) ------------------ | Branch (4102:29): [True: 0, False: 0] | Branch (4102:42): [True: 0, False: 0] ------------------ 4103| 0| { 4104| 0| if (dp->conversion >= 'A' && dp->conversion <= 'Z') ------------------ | Branch (4104:33): [True: 0, False: 0] | Branch (4104:58): [True: 0, False: 0] ------------------ 4105| 0| { 4106| 0| *p++ = 'I'; *p++ = 'N'; *p++ = 'F'; 4107| 0| } 4108| 0| else 4109| 0| { 4110| 0| *p++ = 'i'; *p++ = 'n'; *p++ = 'f'; 4111| 0| } 4112| 0| } 4113| 0| else 4114| 0| { 4115| 0|# if NEED_PRINTF_DOUBLE 4116| 0| pad_ptr = p; 4117| | 4118| 0| if (dp->conversion == 'f' || dp->conversion == 'F') ------------------ | Branch (4118:33): [True: 0, False: 0] | Branch (4118:58): [True: 0, False: 0] ------------------ 4119| 0| { 4120| 0| char *digits; 4121| 0| size_t ndigits; 4122| | 4123| 0| digits = 4124| 0| scale10_round_decimal_double (arg, precision); 4125| 0| if (digits == NULL) ------------------ | Branch (4125:37): [True: 0, False: 0] ------------------ 4126| 0| goto out_of_memory; 4127| 0| ndigits = strlen (digits); 4128| | 4129| 0| if (ndigits > precision) ------------------ | Branch (4129:37): [True: 0, False: 0] ------------------ 4130| 0| do 4131| 0| { 4132| 0| --ndigits; 4133| 0| *p++ = digits[ndigits]; 4134| 0| } 4135| 0| while (ndigits > precision); ------------------ | Branch (4135:42): [True: 0, False: 0] ------------------ 4136| 0| else 4137| 0| *p++ = '0'; 4138| | /* Here ndigits <= precision. */ 4139| 0| if ((flags & FLAG_ALT) || precision > 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4139:37): [True: 0, False: 0] | Branch (4139:59): [True: 0, False: 0] ------------------ 4140| 0| { 4141| 0| *p++ = decimal_point_char (); 4142| 0| for (; precision > ndigits; precision--) ------------------ | Branch (4142:44): [True: 0, False: 0] ------------------ 4143| 0| *p++ = '0'; 4144| 0| while (ndigits > 0) ------------------ | Branch (4144:44): [True: 0, False: 0] ------------------ 4145| 0| { 4146| 0| --ndigits; 4147| 0| *p++ = digits[ndigits]; 4148| 0| } 4149| 0| } 4150| | 4151| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4152| 0| } 4153| 0| else if (dp->conversion == 'e' || dp->conversion == 'E') ------------------ | Branch (4153:38): [True: 0, False: 0] | Branch (4153:63): [True: 0, False: 0] ------------------ 4154| 0| { 4155| 0| int exponent; 4156| | 4157| 0| if (arg == 0.0) ------------------ | Branch (4157:37): [True: 0, False: 0] ------------------ 4158| 0| { 4159| 0| exponent = 0; 4160| 0| *p++ = '0'; 4161| 0| if ((flags & FLAG_ALT) || precision > 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4161:41): [True: 0, False: 0] | Branch (4161:63): [True: 0, False: 0] ------------------ 4162| 0| { 4163| 0| *p++ = decimal_point_char (); 4164| 0| for (; precision > 0; precision--) ------------------ | Branch (4164:48): [True: 0, False: 0] ------------------ 4165| 0| *p++ = '0'; 4166| 0| } 4167| 0| } 4168| 0| else 4169| 0| { 4170| | /* arg > 0.0. */ 4171| 0| int adjusted; 4172| 0| char *digits; 4173| 0| size_t ndigits; 4174| | 4175| 0| exponent = floorlog10 (arg); 4176| 0| adjusted = 0; 4177| 0| for (;;) 4178| 0| { 4179| 0| digits = 4180| 0| scale10_round_decimal_double (arg, 4181| 0| (int)precision - exponent); 4182| 0| if (digits == NULL) ------------------ | Branch (4182:45): [True: 0, False: 0] ------------------ 4183| 0| goto out_of_memory; 4184| 0| ndigits = strlen (digits); 4185| | 4186| 0| if (ndigits == precision + 1) ------------------ | Branch (4186:45): [True: 0, False: 0] ------------------ 4187| 0| break; 4188| 0| if (ndigits < precision ------------------ | Branch (4188:45): [True: 0, False: 0] ------------------ 4189| 0| || ndigits > precision + 2) ------------------ | Branch (4189:48): [True: 0, False: 0] ------------------ 4190| | /* The exponent was not guessed 4191| | precisely enough. */ 4192| 0| abort (); 4193| 0| if (adjusted) ------------------ | Branch (4193:45): [True: 0, False: 0] ------------------ 4194| | /* None of two values of exponent is 4195| | the right one. Prevent an endless 4196| | loop. */ 4197| 0| abort (); 4198| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4199| 0| if (ndigits == precision) ------------------ | Branch (4199:45): [True: 0, False: 0] ------------------ 4200| 0| exponent -= 1; 4201| 0| else 4202| 0| exponent += 1; 4203| 0| adjusted = 1; 4204| 0| } 4205| | /* Here ndigits = precision+1. */ 4206| 0| if (is_borderline (digits, precision)) ------------------ | Branch (4206:41): [True: 0, False: 0] ------------------ 4207| 0| { 4208| | /* Maybe the exponent guess was too high 4209| | and a smaller exponent can be reached 4210| | by turning a 10...0 into 9...9x. */ 4211| 0| char *digits2 = 4212| 0| scale10_round_decimal_double (arg, 4213| 0| (int)precision - exponent + 1); 4214| 0| if (digits2 == NULL) ------------------ | Branch (4214:45): [True: 0, False: 0] ------------------ 4215| 0| { 4216| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4217| 0| goto out_of_memory; 4218| 0| } 4219| 0| if (strlen (digits2) == precision + 1) ------------------ | Branch (4219:45): [True: 0, False: 0] ------------------ 4220| 0| { 4221| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4222| 0| digits = digits2; 4223| 0| exponent -= 1; 4224| 0| } 4225| 0| else 4226| 0| free (digits2); ------------------ | | 35| 0|#define free g_free ------------------ 4227| 0| } 4228| | /* Here ndigits = precision+1. */ 4229| | 4230| 0| *p++ = digits[--ndigits]; 4231| 0| if ((flags & FLAG_ALT) || precision > 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4231:41): [True: 0, False: 0] | Branch (4231:63): [True: 0, False: 0] ------------------ 4232| 0| { 4233| 0| *p++ = decimal_point_char (); 4234| 0| while (ndigits > 0) ------------------ | Branch (4234:48): [True: 0, False: 0] ------------------ 4235| 0| { 4236| 0| --ndigits; 4237| 0| *p++ = digits[ndigits]; 4238| 0| } 4239| 0| } 4240| | 4241| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4242| 0| } 4243| | 4244| 0| *p++ = dp->conversion; /* 'e' or 'E' */ 4245| |# if WIDE_CHAR_VERSION 4246| | { 4247| | static const wchar_t decimal_format[] = 4248| | /* Produce the same number of exponent digits 4249| | as the native printf implementation. */ 4250| |# if (defined _WIN32 && FALSE) && ! defined __CYGWIN__ 4251| | { '%', '+', '.', '3', 'd', '\0' }; 4252| |# else 4253| | { '%', '+', '.', '2', 'd', '\0' }; 4254| |# endif 4255| | SNPRINTF (p, 6 + 1, decimal_format, exponent); 4256| | } 4257| | while (*p != '\0') 4258| | p++; 4259| |# else 4260| 0| { 4261| 0| static const char decimal_format[] = 4262| | /* Produce the same number of exponent digits 4263| | as the native printf implementation. */ 4264| |# if (defined _WIN32 && FALSE) && ! defined __CYGWIN__ 4265| | "%+.3d"; 4266| |# else 4267| 0| "%+.2d"; 4268| 0|# endif 4269| 0| if (sizeof (DCHAR_T) == 1) ------------------ | Branch (4269:39): [True: 0, Folded] ------------------ 4270| 0| { 4271| 0| sprintf ((char *) p, decimal_format, exponent); 4272| 0| while (*p != '\0') ------------------ | Branch (4272:46): [True: 0, False: 0] ------------------ 4273| 0| p++; 4274| 0| } 4275| 0| else 4276| 0| { 4277| 0| char expbuf[6 + 1]; 4278| 0| const char *ep; 4279| 0| sprintf (expbuf, decimal_format, exponent); 4280| 0| for (ep = expbuf; (*p = *ep) != '\0'; ep++) ------------------ | Branch (4280:57): [True: 0, False: 0] ------------------ 4281| 0| p++; 4282| 0| } 4283| 0| } 4284| 0|# endif 4285| 0| } 4286| 0| else if (dp->conversion == 'g' || dp->conversion == 'G') ------------------ | Branch (4286:38): [True: 0, False: 0] | Branch (4286:63): [True: 0, False: 0] ------------------ 4287| 0| { 4288| 0| if (precision == 0) ------------------ | Branch (4288:37): [True: 0, False: 0] ------------------ 4289| 0| precision = 1; 4290| | /* precision >= 1. */ 4291| | 4292| 0| if (arg == 0.0) ------------------ | Branch (4292:37): [True: 0, False: 0] ------------------ 4293| | /* The exponent is 0, >= -4, < precision. 4294| | Use fixed-point notation. */ 4295| 0| { 4296| 0| size_t ndigits = precision; 4297| | /* Number of trailing zeroes that have to be 4298| | dropped. */ 4299| 0| size_t nzeroes = 4300| 0| (flags & FLAG_ALT ? 0 : precision - 1); ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4300:40): [True: 0, False: 0] ------------------ 4301| | 4302| 0| --ndigits; 4303| 0| *p++ = '0'; 4304| 0| if ((flags & FLAG_ALT) || ndigits > nzeroes) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4304:41): [True: 0, False: 0] | Branch (4304:63): [True: 0, False: 0] ------------------ 4305| 0| { 4306| 0| *p++ = decimal_point_char (); 4307| 0| while (ndigits > nzeroes) ------------------ | Branch (4307:48): [True: 0, False: 0] ------------------ 4308| 0| { 4309| 0| --ndigits; 4310| 0| *p++ = '0'; 4311| 0| } 4312| 0| } 4313| 0| } 4314| 0| else 4315| 0| { 4316| | /* arg > 0.0. */ 4317| 0| int exponent; 4318| 0| int adjusted; 4319| 0| char *digits; 4320| 0| size_t ndigits; 4321| 0| size_t nzeroes; 4322| | 4323| 0| exponent = floorlog10 (arg); 4324| 0| adjusted = 0; 4325| 0| for (;;) 4326| 0| { 4327| 0| digits = 4328| 0| scale10_round_decimal_double (arg, 4329| 0| (int)(precision - 1) - exponent); 4330| 0| if (digits == NULL) ------------------ | Branch (4330:45): [True: 0, False: 0] ------------------ 4331| 0| goto out_of_memory; 4332| 0| ndigits = strlen (digits); 4333| | 4334| 0| if (ndigits == precision) ------------------ | Branch (4334:45): [True: 0, False: 0] ------------------ 4335| 0| break; 4336| 0| if (ndigits < precision - 1 ------------------ | Branch (4336:45): [True: 0, False: 0] ------------------ 4337| 0| || ndigits > precision + 1) ------------------ | Branch (4337:48): [True: 0, False: 0] ------------------ 4338| | /* The exponent was not guessed 4339| | precisely enough. */ 4340| 0| abort (); 4341| 0| if (adjusted) ------------------ | Branch (4341:45): [True: 0, False: 0] ------------------ 4342| | /* None of two values of exponent is 4343| | the right one. Prevent an endless 4344| | loop. */ 4345| 0| abort (); 4346| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4347| 0| if (ndigits < precision) ------------------ | Branch (4347:45): [True: 0, False: 0] ------------------ 4348| 0| exponent -= 1; 4349| 0| else 4350| 0| exponent += 1; 4351| 0| adjusted = 1; 4352| 0| } 4353| | /* Here ndigits = precision. */ 4354| 0| if (is_borderline (digits, precision - 1)) ------------------ | Branch (4354:41): [True: 0, False: 0] ------------------ 4355| 0| { 4356| | /* Maybe the exponent guess was too high 4357| | and a smaller exponent can be reached 4358| | by turning a 10...0 into 9...9x. */ 4359| 0| char *digits2 = 4360| 0| scale10_round_decimal_double (arg, 4361| 0| (int)(precision - 1) - exponent + 1); 4362| 0| if (digits2 == NULL) ------------------ | Branch (4362:45): [True: 0, False: 0] ------------------ 4363| 0| { 4364| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4365| 0| goto out_of_memory; 4366| 0| } 4367| 0| if (strlen (digits2) == precision) ------------------ | Branch (4367:45): [True: 0, False: 0] ------------------ 4368| 0| { 4369| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4370| 0| digits = digits2; 4371| 0| exponent -= 1; 4372| 0| } 4373| 0| else 4374| 0| free (digits2); ------------------ | | 35| 0|#define free g_free ------------------ 4375| 0| } 4376| | /* Here ndigits = precision. */ 4377| | 4378| | /* Determine the number of trailing zeroes 4379| | that have to be dropped. */ 4380| 0| nzeroes = 0; 4381| 0| if ((flags & FLAG_ALT) == 0) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4381:41): [True: 0, False: 0] ------------------ 4382| 0| while (nzeroes < ndigits ------------------ | Branch (4382:46): [True: 0, False: 0] ------------------ 4383| 0| && digits[nzeroes] == '0') ------------------ | Branch (4383:49): [True: 0, False: 0] ------------------ 4384| 0| nzeroes++; 4385| | 4386| | /* The exponent is now determined. */ 4387| 0| if (exponent >= -4 ------------------ | Branch (4387:41): [True: 0, False: 0] ------------------ 4388| 0| && exponent < (long)precision) ------------------ | Branch (4388:44): [True: 0, False: 0] ------------------ 4389| 0| { 4390| | /* Fixed-point notation: 4391| | max(exponent,0)+1 digits, then the 4392| | decimal point, then the remaining 4393| | digits without trailing zeroes. */ 4394| 0| if (exponent >= 0) ------------------ | Branch (4394:45): [True: 0, False: 0] ------------------ 4395| 0| { 4396| 0| size_t ecount = exponent + 1; 4397| | /* Note: ecount <= precision = ndigits. */ 4398| 0| for (; ecount > 0; ecount--) ------------------ | Branch (4398:52): [True: 0, False: 0] ------------------ 4399| 0| *p++ = digits[--ndigits]; 4400| 0| if ((flags & FLAG_ALT) || ndigits > nzeroes) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4400:49): [True: 0, False: 0] | Branch (4400:71): [True: 0, False: 0] ------------------ 4401| 0| { 4402| 0| *p++ = decimal_point_char (); 4403| 0| while (ndigits > nzeroes) ------------------ | Branch (4403:56): [True: 0, False: 0] ------------------ 4404| 0| { 4405| 0| --ndigits; 4406| 0| *p++ = digits[ndigits]; 4407| 0| } 4408| 0| } 4409| 0| } 4410| 0| else 4411| 0| { 4412| 0| size_t ecount = -exponent - 1; 4413| 0| *p++ = '0'; 4414| 0| *p++ = decimal_point_char (); 4415| 0| for (; ecount > 0; ecount--) ------------------ | Branch (4415:52): [True: 0, False: 0] ------------------ 4416| 0| *p++ = '0'; 4417| 0| while (ndigits > nzeroes) ------------------ | Branch (4417:52): [True: 0, False: 0] ------------------ 4418| 0| { 4419| 0| --ndigits; 4420| 0| *p++ = digits[ndigits]; 4421| 0| } 4422| 0| } 4423| 0| } 4424| 0| else 4425| 0| { 4426| | /* Exponential notation. */ 4427| 0| *p++ = digits[--ndigits]; 4428| 0| if ((flags & FLAG_ALT) || ndigits > nzeroes) ------------------ | | 37| 0|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4428:45): [True: 0, False: 0] | Branch (4428:67): [True: 0, False: 0] ------------------ 4429| 0| { 4430| 0| *p++ = decimal_point_char (); 4431| 0| while (ndigits > nzeroes) ------------------ | Branch (4431:52): [True: 0, False: 0] ------------------ 4432| 0| { 4433| 0| --ndigits; 4434| 0| *p++ = digits[ndigits]; 4435| 0| } 4436| 0| } 4437| 0| *p++ = dp->conversion - 'G' + 'E'; /* 'e' or 'E' */ 4438| |# if WIDE_CHAR_VERSION 4439| | { 4440| | static const wchar_t decimal_format[] = 4441| | /* Produce the same number of exponent digits 4442| | as the native printf implementation. */ 4443| |# if (defined _WIN32 && FALSE) && ! defined __CYGWIN__ 4444| | { '%', '+', '.', '3', 'd', '\0' }; 4445| |# else 4446| | { '%', '+', '.', '2', 'd', '\0' }; 4447| |# endif 4448| | SNPRINTF (p, 6 + 1, decimal_format, exponent); 4449| | } 4450| | while (*p != '\0') 4451| | p++; 4452| |# else 4453| 0| { 4454| 0| static const char decimal_format[] = 4455| | /* Produce the same number of exponent digits 4456| | as the native printf implementation. */ 4457| |# if (defined _WIN32 && FALSE) && ! defined __CYGWIN__ 4458| | "%+.3d"; 4459| |# else 4460| 0| "%+.2d"; 4461| 0|# endif 4462| 0| if (sizeof (DCHAR_T) == 1) ------------------ | Branch (4462:47): [True: 0, Folded] ------------------ 4463| 0| { 4464| 0| sprintf ((char *) p, decimal_format, exponent); 4465| 0| while (*p != '\0') ------------------ | Branch (4465:54): [True: 0, False: 0] ------------------ 4466| 0| p++; 4467| 0| } 4468| 0| else 4469| 0| { 4470| 0| char expbuf[6 + 1]; 4471| 0| const char *ep; 4472| 0| sprintf (expbuf, decimal_format, exponent); 4473| 0| for (ep = expbuf; (*p = *ep) != '\0'; ep++) ------------------ | Branch (4473:65): [True: 0, False: 0] ------------------ 4474| 0| p++; 4475| 0| } 4476| 0| } 4477| 0|# endif 4478| 0| } 4479| | 4480| 0| free (digits); ------------------ | | 35| 0|#define free g_free ------------------ 4481| 0| } 4482| 0| } 4483| 0| else 4484| 0| abort (); 4485| |# else 4486| | /* arg is finite. */ 4487| | if (!(arg == 0.0)) 4488| | abort (); 4489| | 4490| | pad_ptr = p; 4491| | 4492| | if (dp->conversion == 'f' || dp->conversion == 'F') 4493| | { 4494| | *p++ = '0'; 4495| | if ((flags & FLAG_ALT) || precision > 0) 4496| | { 4497| | *p++ = decimal_point_char (); 4498| | for (; precision > 0; precision--) 4499| | *p++ = '0'; 4500| | } 4501| | } 4502| | else if (dp->conversion == 'e' || dp->conversion == 'E') 4503| | { 4504| | *p++ = '0'; 4505| | if ((flags & FLAG_ALT) || precision > 0) 4506| | { 4507| | *p++ = decimal_point_char (); 4508| | for (; precision > 0; precision--) 4509| | *p++ = '0'; 4510| | } 4511| | *p++ = dp->conversion; /* 'e' or 'E' */ 4512| | *p++ = '+'; 4513| | /* Produce the same number of exponent digits as 4514| | the native printf implementation. */ 4515| |# if (defined _WIN32 && FALSE) && ! defined __CYGWIN__ 4516| | *p++ = '0'; 4517| |# endif 4518| | *p++ = '0'; 4519| | *p++ = '0'; 4520| | } 4521| | else if (dp->conversion == 'g' || dp->conversion == 'G') 4522| | { 4523| | *p++ = '0'; 4524| | if (flags & FLAG_ALT) 4525| | { 4526| | size_t ndigits = 4527| | (precision > 0 ? precision - 1 : 0); 4528| | *p++ = decimal_point_char (); 4529| | for (; ndigits > 0; --ndigits) 4530| | *p++ = '0'; 4531| | } 4532| | } 4533| | else 4534| | abort (); 4535| |# endif 4536| 0| } 4537| 0| } 4538| 0| } 4539| 0|# endif 4540| | 4541| | /* The generated string now extends from tmp to p, with the 4542| | zero padding insertion point being at pad_ptr. */ 4543| 0| count = p - tmp; 4544| | 4545| 0| if (count < width) ------------------ | Branch (4545:21): [True: 0, False: 0] ------------------ 4546| 0| { 4547| 0| size_t pad = width - count; 4548| 0| DCHAR_T *end = p + pad; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 4549| | 4550| 0| if (flags & FLAG_LEFT) ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ | Branch (4550:25): [True: 0, False: 0] ------------------ 4551| 0| { 4552| | /* Pad with spaces on the right. */ 4553| 0| for (; pad > 0; pad--) ------------------ | Branch (4553:32): [True: 0, False: 0] ------------------ 4554| 0| *p++ = ' '; 4555| 0| } 4556| 0| else if ((flags & FLAG_ZERO) && pad_ptr != NULL) ------------------ | | 38| 0|#define FLAG_ZERO 32 ------------------ | Branch (4556:30): [True: 0, False: 0] | Branch (4556:53): [True: 0, False: 0] ------------------ 4557| 0| { 4558| | /* Pad with zeroes. */ 4559| 0| DCHAR_T *q = end; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 4560| | 4561| 0| while (p > pad_ptr) ------------------ | Branch (4561:32): [True: 0, False: 0] ------------------ 4562| 0| *--q = *--p; 4563| 0| for (; pad > 0; pad--) ------------------ | Branch (4563:32): [True: 0, False: 0] ------------------ 4564| 0| *p++ = '0'; 4565| 0| } 4566| 0| else 4567| 0| { 4568| | /* Pad with spaces on the left. */ 4569| 0| DCHAR_T *q = end; ------------------ | | 147| 0|# define DCHAR_T char ------------------ 4570| | 4571| 0| while (p > tmp) ------------------ | Branch (4571:32): [True: 0, False: 0] ------------------ 4572| 0| *--q = *--p; 4573| 0| for (; pad > 0; pad--) ------------------ | Branch (4573:32): [True: 0, False: 0] ------------------ 4574| 0| *p++ = ' '; 4575| 0| } 4576| | 4577| 0| p = end; 4578| 0| } 4579| | 4580| 0| count = p - tmp; 4581| | 4582| 0| if (count >= tmp_length) ------------------ | Branch (4582:21): [True: 0, False: 0] ------------------ 4583| | /* tmp_length was incorrectly calculated - fix the 4584| | code above! */ 4585| 0| abort (); 4586| | 4587| | /* Make room for the result. */ 4588| 0| if (count >= allocated - length) ------------------ | Branch (4588:21): [True: 0, False: 0] ------------------ 4589| 0| { 4590| 0| size_t n = xsum (length, count); 4591| | 4592| 0| ENSURE_ALLOCATION (n); ------------------ | | 1863| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 0, False: 0] | | ------------------ | | 1864| 0| { \ | | 1865| 0| size_t memory_size; \ | | 1866| 0| DCHAR_T *memory; \ | | ------------------ | | | | 147| 0|# define DCHAR_T char | | ------------------ | | 1867| 0| \ | | 1868| 0| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 0, False: 0] | | ------------------ | | 1869| 0| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 0] | | ------------------ | | 1870| 0| allocated = (needed); \ | | 1871| 0| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1872| 0| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 0| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 1873| 0| goto out_of_memory; \ | | 1874| 0| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 0] | | | Branch (1874:36): [True: 0, False: 0] | | ------------------ | | 1875| 0| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 0| else \ | | 1877| 0| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 0|#define realloc g_realloc | | ------------------ | | 1878| 0| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 0] | | ------------------ | | 1879| 0| goto out_of_memory; \ | | 1880| 0| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 0] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 0| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 0| result = memory; \ | | 1883| 0| } ------------------ 4593| 0| } 4594| | 4595| | /* Append the result. */ 4596| 0| memcpy (result + length, tmp, count * sizeof (DCHAR_T)); 4597| 0| if (tmp != tmpbuf) ------------------ | Branch (4597:21): [True: 0, False: 0] ------------------ 4598| 0| free (tmp); ------------------ | | 35| 0|#define free g_free ------------------ 4599| 0| length += count; 4600| 0| } 4601| 484k|#endif 4602| 484k| else 4603| 484k| { 4604| 484k| arg_type type = a.arg[dp->arg_index].type; 4605| 484k| int flags = dp->flags; 4606| |#if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION 4607| | int has_width; 4608| |#endif 4609| 484k|#if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION 4610| 484k| size_t width; 4611| 484k|#endif 4612| 484k|#if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || NEED_PRINTF_UNBOUNDED_PRECISION 4613| 484k| int has_precision; 4614| 484k| size_t precision; 4615| 484k|#endif 4616| |#if NEED_PRINTF_UNBOUNDED_PRECISION 4617| | int prec_ourselves; 4618| |#else 4619| 484k|# define prec_ourselves 0 4620| 484k|#endif 4621| |#if NEED_PRINTF_FLAG_LEFTADJUST 4622| |# define pad_ourselves 1 4623| |#elif !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION 4624| | int pad_ourselves; 4625| |#else 4626| 484k|# define pad_ourselves 0 4627| 484k|#endif 4628| 484k| TCHAR_T *fbp; ------------------ | | 148| 484k|# define TCHAR_T char ------------------ 4629| 484k| unsigned int prefix_count; 4630| 484k| int prefixes[2] IF_LINT (= { 0 }); ------------------ | | 212| 484k|# define IF_LINT(Code) Code ------------------ 4631| 484k| int orig_errno; 4632| 484k|#if !USE_SNPRINTF 4633| 484k| size_t tmp_length; 4634| 484k| TCHAR_T tmpbuf[700]; ------------------ | | 148| 484k|# define TCHAR_T char ------------------ 4635| 484k| TCHAR_T *tmp; ------------------ | | 148| 484k|# define TCHAR_T char ------------------ 4636| 484k|#endif 4637| | 4638| |#if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION 4639| | has_width = 0; 4640| |#endif 4641| 484k|#if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION 4642| 484k| width = 0; 4643| 484k| if (dp->width_start != dp->width_end) ------------------ | Branch (4643:21): [True: 3.39k, False: 480k] ------------------ 4644| 3.39k| { 4645| 3.39k| if (dp->width_arg_index != ARG_NONE) ------------------ | | 44| 3.39k|#define ARG_NONE (~(size_t)0) ------------------ | Branch (4645:25): [True: 0, False: 3.39k] ------------------ 4646| 0| { 4647| 0| int arg; 4648| | 4649| 0| if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) ------------------ | Branch (4649:29): [True: 0, False: 0] ------------------ 4650| 0| abort (); 4651| 0| arg = a.arg[dp->width_arg_index].a.a_int; 4652| 0| width = arg; 4653| 0| if (arg < 0) ------------------ | Branch (4653:29): [True: 0, False: 0] ------------------ 4654| 0| { 4655| | /* "A negative field width is taken as a '-' flag 4656| | followed by a positive field width." */ 4657| 0| flags |= FLAG_LEFT; ------------------ | | 34| 0|#define FLAG_LEFT 2 /* - flag */ ------------------ 4658| 0| width = -width; 4659| 0| } 4660| 0| } 4661| 3.39k| else 4662| 3.39k| { 4663| 3.39k| const FCHAR_T *digitp = dp->width_start; 4664| | 4665| 3.39k| do 4666| 3.39k| width = xsum (xtimes (width, 10), *digitp++ - '0'); ------------------ | | 108| 3.39k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 3.39k|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 3.39k|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 3.39k|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 3.39k|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 3.39k, False: 0] | | ------------------ ------------------ 4667| 3.39k| while (digitp != dp->width_end); ------------------ | Branch (4667:32): [True: 0, False: 3.39k] ------------------ 4668| 3.39k| } 4669| |#if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION 4670| | has_width = 1; 4671| |#endif 4672| 3.39k| } 4673| 484k|#endif 4674| | 4675| 484k|#if !USE_SNPRINTF || !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF || NEED_PRINTF_UNBOUNDED_PRECISION 4676| 484k| has_precision = 0; 4677| 484k| precision = 6; 4678| 484k| if (dp->precision_start != dp->precision_end) ------------------ | Branch (4678:21): [True: 0, False: 484k] ------------------ 4679| 0| { 4680| 0| if (dp->precision_arg_index != ARG_NONE) ------------------ | | 44| 0|#define ARG_NONE (~(size_t)0) ------------------ | Branch (4680:25): [True: 0, False: 0] ------------------ 4681| 0| { 4682| 0| int arg; 4683| | 4684| 0| if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) ------------------ | Branch (4684:29): [True: 0, False: 0] ------------------ 4685| 0| abort (); 4686| 0| arg = a.arg[dp->precision_arg_index].a.a_int; 4687| | /* "A negative precision is taken as if the precision 4688| | were omitted." */ 4689| 0| if (arg >= 0) ------------------ | Branch (4689:29): [True: 0, False: 0] ------------------ 4690| 0| { 4691| 0| precision = arg; 4692| 0| has_precision = 1; 4693| 0| } 4694| 0| } 4695| 0| else 4696| 0| { 4697| 0| const FCHAR_T *digitp = dp->precision_start + 1; 4698| | 4699| 0| precision = 0; 4700| 0| while (digitp != dp->precision_end) ------------------ | Branch (4700:32): [True: 0, False: 0] ------------------ 4701| 0| precision = xsum (xtimes (precision, 10), *digitp++ - '0'); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 4702| 0| has_precision = 1; 4703| 0| } 4704| 0| } 4705| 484k|#endif 4706| | 4707| | /* Decide whether to handle the precision ourselves. */ 4708| |#if NEED_PRINTF_UNBOUNDED_PRECISION 4709| | switch (dp->conversion) 4710| | { 4711| | case 'd': case 'i': case 'u': 4712| | case 'o': 4713| | case 'x': case 'X': case 'p': 4714| | prec_ourselves = has_precision && (precision > 0); 4715| | break; 4716| | default: 4717| | prec_ourselves = 0; 4718| | break; 4719| | } 4720| |#endif 4721| | 4722| | /* Decide whether to perform the padding ourselves. */ 4723| |#if !NEED_PRINTF_FLAG_LEFTADJUST && (!DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION) 4724| | switch (dp->conversion) 4725| | { 4726| |# if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO 4727| | /* If we need conversion from TCHAR_T[] to DCHAR_T[], we need 4728| | to perform the padding after this conversion. Functions 4729| | with unistdio extensions perform the padding based on 4730| | character count rather than element count. */ 4731| | case 'c': case 's': 4732| |# endif 4733| |# if NEED_PRINTF_FLAG_ZERO 4734| | case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': 4735| | case 'a': case 'A': 4736| |# endif 4737| | pad_ourselves = 1; 4738| | break; 4739| | default: 4740| | pad_ourselves = prec_ourselves; 4741| | break; 4742| | } 4743| |#endif 4744| | 4745| 484k|#if !USE_SNPRINTF 4746| | /* Allocate a temporary buffer of sufficient size for calling 4747| | sprintf. */ 4748| 484k| tmp_length = 4749| 484k| MAX_ROOM_NEEDED (&a, dp->arg_index, dp->conversion, type, ------------------ | | 1543| 484k|# define MAX_ROOM_NEEDED max_room_needed ------------------ 4750| 484k| flags, width, has_precision, precision, 4751| 484k| pad_ourselves); ------------------ | | 4626| 484k|# define pad_ourselves 0 ------------------ 4752| | 4753| 484k| if (tmp_length <= sizeof (tmpbuf) / sizeof (TCHAR_T)) ------------------ | Branch (4753:21): [True: 484k, False: 0] ------------------ 4754| 484k| tmp = tmpbuf; 4755| 0| else 4756| 0| { 4757| 0| size_t tmp_memsize = xtimes (tmp_length, sizeof (TCHAR_T)); ------------------ | | 108| 0| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 0, False: 0] | | ------------------ ------------------ 4758| | 4759| 0| if (size_overflow_p (tmp_memsize)) ------------------ | | 112| 0| ((SIZE) == G_MAXSIZE) | | ------------------ | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (112:3): [True: 0, False: 0] | | ------------------ ------------------ 4760| | /* Overflow, would lead to out of memory. */ 4761| 0| goto out_of_memory; 4762| 0| tmp = (TCHAR_T *) malloc (tmp_memsize); ------------------ | | 33| 0|#define malloc g_malloc ------------------ 4763| 0| if (tmp == NULL) ------------------ | Branch (4763:25): [True: 0, False: 0] ------------------ 4764| | /* Out of memory. */ 4765| 0| goto out_of_memory; 4766| 0| } 4767| 484k|#endif 4768| | 4769| | /* Construct the format string for calling snprintf or 4770| | sprintf. */ 4771| 484k| fbp = buf; 4772| 484k| *fbp++ = '%'; 4773| |#if NEED_PRINTF_FLAG_GROUPING 4774| | /* The underlying implementation doesn't support the ' flag. 4775| | Produce no grouping characters in this case; this is 4776| | acceptable because the grouping is locale dependent. */ 4777| |#else 4778| 484k| if (flags & FLAG_GROUP) ------------------ | | 33| 484k|#define FLAG_GROUP 1 /* ' flag */ ------------------ | Branch (4778:21): [True: 0, False: 484k] ------------------ 4779| 0| *fbp++ = '\''; 4780| 484k|#endif 4781| 484k| if (flags & FLAG_LEFT) ------------------ | | 34| 484k|#define FLAG_LEFT 2 /* - flag */ ------------------ | Branch (4781:21): [True: 0, False: 484k] ------------------ 4782| 0| *fbp++ = '-'; 4783| 484k| if (flags & FLAG_SHOWSIGN) ------------------ | | 35| 484k|#define FLAG_SHOWSIGN 4 /* + flag */ ------------------ | Branch (4783:21): [True: 0, False: 484k] ------------------ 4784| 0| *fbp++ = '+'; 4785| 484k| if (flags & FLAG_SPACE) ------------------ | | 36| 484k|#define FLAG_SPACE 8 /* space flag */ ------------------ | Branch (4785:21): [True: 0, False: 484k] ------------------ 4786| 0| *fbp++ = ' '; 4787| 484k| if (flags & FLAG_ALT) ------------------ | | 37| 484k|#define FLAG_ALT 16 /* # flag */ ------------------ | Branch (4787:21): [True: 0, False: 484k] ------------------ 4788| 0| *fbp++ = '#'; 4789| 484k|#if __GLIBC__ >= 2 && !defined __UCLIBC__ 4790| 484k| if (flags & FLAG_LOCALIZED) ------------------ | | 40| 484k|# define FLAG_LOCALIZED 64 /* I flag, uses localized digits */ ------------------ | Branch (4790:21): [True: 0, False: 484k] ------------------ 4791| 0| *fbp++ = 'I'; 4792| 484k|#endif 4793| 484k| if (!pad_ourselves) ------------------ | | 4626| 484k|# define pad_ourselves 0 ------------------ | Branch (4793:21): [True: 484k, Folded] ------------------ 4794| 484k| { 4795| 484k| if (flags & FLAG_ZERO) ------------------ | | 38| 484k|#define FLAG_ZERO 32 ------------------ | Branch (4795:25): [True: 3.39k, False: 480k] ------------------ 4796| 3.39k| *fbp++ = '0'; 4797| 484k| if (dp->width_start != dp->width_end) ------------------ | Branch (4797:25): [True: 3.39k, False: 480k] ------------------ 4798| 3.39k| { 4799| 3.39k| size_t n = dp->width_end - dp->width_start; 4800| | /* The width specification is known to consist only 4801| | of standard ASCII characters. */ 4802| 3.39k| if (sizeof (FCHAR_T) == sizeof (TCHAR_T)) ------------------ | Branch (4802:29): [True: 3.39k, Folded] ------------------ 4803| 3.39k| { 4804| 3.39k| memcpy (fbp, dp->width_start, n * sizeof (TCHAR_T)); 4805| 3.39k| fbp += n; 4806| 3.39k| } 4807| 0| else 4808| 0| { 4809| 0| const FCHAR_T *mp = dp->width_start; 4810| 0| do 4811| 0| *fbp++ = *mp++; 4812| 0| while (--n > 0); ------------------ | Branch (4812:36): [True: 0, False: 0] ------------------ 4813| 0| } 4814| 3.39k| } 4815| 484k| } 4816| 484k| if (!prec_ourselves) ------------------ | | 4619| 484k|# define prec_ourselves 0 ------------------ | Branch (4816:21): [True: 484k, Folded] ------------------ 4817| 484k| { 4818| 484k| if (dp->precision_start != dp->precision_end) ------------------ | Branch (4818:25): [True: 0, False: 484k] ------------------ 4819| 0| { 4820| 0| size_t n = dp->precision_end - dp->precision_start; 4821| | /* The precision specification is known to consist only 4822| | of standard ASCII characters. */ 4823| 0| if (sizeof (FCHAR_T) == sizeof (TCHAR_T)) ------------------ | Branch (4823:29): [True: 0, Folded] ------------------ 4824| 0| { 4825| 0| memcpy (fbp, dp->precision_start, n * sizeof (TCHAR_T)); 4826| 0| fbp += n; 4827| 0| } 4828| 0| else 4829| 0| { 4830| 0| const FCHAR_T *mp = dp->precision_start; 4831| 0| do 4832| 0| *fbp++ = *mp++; 4833| 0| while (--n > 0); ------------------ | Branch (4833:36): [True: 0, False: 0] ------------------ 4834| 0| } 4835| 0| } 4836| 484k| } 4837| | 4838| 484k| switch (type) 4839| 484k| { 4840| 0|#if HAVE_LONG_LONG 4841| 0| case TYPE_LONGLONGINT: ------------------ | Branch (4841:19): [True: 0, False: 484k] ------------------ 4842| 0| case TYPE_ULONGLONGINT: ------------------ | Branch (4842:19): [True: 0, False: 484k] ------------------ 4843| |# if (defined _WIN32 && FALSE) && ! defined __CYGWIN__ 4844| | *fbp++ = 'I'; 4845| | *fbp++ = '6'; 4846| | *fbp++ = '4'; 4847| | break; 4848| |# else 4849| 0| *fbp++ = 'l'; 4850| 0|# endif 4851| 0|#endif 4852| 0| FALLTHROUGH; ------------------ | | 125| 0|# define FALLTHROUGH ((void) 0) ------------------ 4853| 0| case TYPE_LONGINT: ------------------ | Branch (4853:19): [True: 0, False: 484k] ------------------ 4854| 9.27k| case TYPE_ULONGINT: ------------------ | Branch (4854:19): [True: 9.27k, False: 474k] ------------------ 4855| 9.27k|#if HAVE_WINT_T 4856| 9.27k| case TYPE_WIDE_CHAR: ------------------ | Branch (4856:19): [True: 0, False: 484k] ------------------ 4857| 9.27k|#endif 4858| 9.27k|#if HAVE_WCHAR_T 4859| 9.27k| case TYPE_WIDE_STRING: ------------------ | Branch (4859:19): [True: 0, False: 484k] ------------------ 4860| 9.27k|#endif 4861| 9.27k| *fbp++ = 'l'; 4862| 9.27k| break; 4863| 0| case TYPE_LONGDOUBLE: ------------------ | Branch (4863:19): [True: 0, False: 484k] ------------------ 4864| 0| *fbp++ = 'L'; 4865| 0| break; 4866| 474k| default: ------------------ | Branch (4866:19): [True: 474k, False: 9.27k] ------------------ 4867| 474k| break; 4868| 484k| } 4869| |#if NEED_PRINTF_DIRECTIVE_F 4870| | if (dp->conversion == 'F') 4871| | *fbp = 'f'; 4872| | else 4873| |#endif 4874| 484k| *fbp = dp->conversion; 4875| |#if USE_SNPRINTF 4876| |# if ! (((__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) \ 4877| | && !defined __UCLIBC__) \ 4878| | || (defined __APPLE__ && defined __MACH__) \ 4879| | || defined __ANDROID__ \ 4880| | || (defined _WIN32 && ! defined __CYGWIN__)) 4881| | fbp[1] = '%'; 4882| | fbp[2] = 'n'; 4883| | fbp[3] = '\0'; 4884| |# else 4885| | /* On glibc2 systems from glibc >= 2.3 - probably also older 4886| | ones - we know that snprintf's return value conforms to 4887| | ISO C 99: the tests gl_SNPRINTF_RETVAL_C99 and 4888| | gl_SNPRINTF_TRUNCATION_C99 pass. 4889| | Therefore we can avoid using %n in this situation. 4890| | On glibc2 systems from 2004-10-18 or newer, the use of %n 4891| | in format strings in writable memory may crash the program 4892| | (if compiled with _FORTIFY_SOURCE=2), so we should avoid it 4893| | in this situation. */ 4894| | /* On Mac OS X 10.3 or newer, we know that snprintf's return 4895| | value conforms to ISO C 99: the tests gl_SNPRINTF_RETVAL_C99 4896| | and gl_SNPRINTF_TRUNCATION_C99 pass. 4897| | Therefore we can avoid using %n in this situation. 4898| | On Mac OS X 10.13 or newer, the use of %n in format strings 4899| | in writable memory by default crashes the program, so we 4900| | should avoid it in this situation. */ 4901| | /* On Android, we know that snprintf's return value conforms to 4902| | ISO C 99: the tests gl_SNPRINTF_RETVAL_C99 and 4903| | gl_SNPRINTF_TRUNCATION_C99 pass. 4904| | Therefore we can avoid using %n in this situation. 4905| | Starting on 2018-03-07, the use of %n in format strings 4906| | produces a fatal error (see 4907| | ), 4908| | so we should avoid it. */ 4909| | /* On native Windows systems (such as mingw), we can avoid using 4910| | %n because: 4911| | - Although the gl_SNPRINTF_TRUNCATION_C99 test fails, 4912| | snprintf does not write more than the specified number 4913| | of bytes. (snprintf (buf, 3, "%d %d", 4567, 89) writes 4914| | '4', '5', '6' into buf, not '4', '5', '\0'.) 4915| | - Although the gl_SNPRINTF_RETVAL_C99 test fails, snprintf 4916| | allows us to recognize the case of an insufficient 4917| | buffer size: it returns -1 in this case. 4918| | On native Windows systems (such as mingw) where the OS is 4919| | Windows Vista, the use of %n in format strings by default 4920| | crashes the program. See 4921| | and 4922| | 4923| | So we should avoid %n in this situation. */ 4924| | fbp[1] = '\0'; 4925| |# endif 4926| |#else 4927| 484k| fbp[1] = '\0'; 4928| 484k|#endif 4929| | 4930| | /* Construct the arguments for calling snprintf or sprintf. */ 4931| 484k| prefix_count = 0; 4932| 484k| if (!pad_ourselves && dp->width_arg_index != ARG_NONE) ------------------ | | 4626| 968k|# define pad_ourselves 0 ------------------ if (!pad_ourselves && dp->width_arg_index != ARG_NONE) ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ | Branch (4932:21): [True: 484k, Folded] | Branch (4932:39): [True: 0, False: 484k] ------------------ 4933| 0| { 4934| 0| if (!(a.arg[dp->width_arg_index].type == TYPE_INT)) ------------------ | Branch (4934:25): [True: 0, False: 0] ------------------ 4935| 0| abort (); 4936| 0| prefixes[prefix_count++] = a.arg[dp->width_arg_index].a.a_int; 4937| 0| } 4938| 484k| if (!prec_ourselves && dp->precision_arg_index != ARG_NONE) ------------------ | | 4619| 968k|# define prec_ourselves 0 ------------------ if (!prec_ourselves && dp->precision_arg_index != ARG_NONE) ------------------ | | 44| 484k|#define ARG_NONE (~(size_t)0) ------------------ | Branch (4938:21): [True: 484k, Folded] | Branch (4938:40): [True: 0, False: 484k] ------------------ 4939| 0| { 4940| 0| if (!(a.arg[dp->precision_arg_index].type == TYPE_INT)) ------------------ | Branch (4940:25): [True: 0, False: 0] ------------------ 4941| 0| abort (); 4942| 0| prefixes[prefix_count++] = a.arg[dp->precision_arg_index].a.a_int; 4943| 0| } 4944| | 4945| |#if USE_SNPRINTF 4946| | /* The SNPRINTF result is appended after result[0..length]. 4947| | The latter is an array of DCHAR_T; SNPRINTF appends an 4948| | array of TCHAR_T to it. This is possible because 4949| | sizeof (TCHAR_T) divides sizeof (DCHAR_T) and 4950| | alignof (TCHAR_T) <= alignof (DCHAR_T). */ 4951| |# define TCHARS_PER_DCHAR (sizeof (DCHAR_T) / sizeof (TCHAR_T)) 4952| | /* Ensure that maxlen below will be >= 2. Needed on BeOS, 4953| | where an snprintf() with maxlen==1 acts like sprintf(). */ 4954| | ENSURE_ALLOCATION (xsum (length, 4955| | (2 + TCHARS_PER_DCHAR - 1) 4956| | / TCHARS_PER_DCHAR)); 4957| | /* Prepare checking whether snprintf returns the count 4958| | via %n. */ 4959| | *(TCHAR_T *) (result + length) = '\0'; 4960| |#endif 4961| | 4962| 484k| orig_errno = errno; 4963| | 4964| 484k| for (;;) 4965| 484k| { 4966| 484k| int count = -1; 4967| | 4968| |#if USE_SNPRINTF 4969| | int retcount = 0; 4970| | size_t maxlen = allocated - length; 4971| | /* SNPRINTF can fail if its second argument is 4972| | > INT_MAX. */ 4973| | if (maxlen > INT_MAX / TCHARS_PER_DCHAR) 4974| | maxlen = INT_MAX / TCHARS_PER_DCHAR; 4975| | maxlen = maxlen * TCHARS_PER_DCHAR; 4976| |# define SNPRINTF_BUF(arg) \ 4977| | switch (prefix_count) \ 4978| | { \ 4979| | case 0: \ 4980| | retcount = SNPRINTF ((TCHAR_T *) (result + length), \ 4981| | maxlen, buf, \ 4982| | arg, &count); \ 4983| | break; \ 4984| | case 1: \ 4985| | retcount = SNPRINTF ((TCHAR_T *) (result + length), \ 4986| | maxlen, buf, \ 4987| | prefixes[0], arg, &count); \ 4988| | break; \ 4989| | case 2: \ 4990| | retcount = SNPRINTF ((TCHAR_T *) (result + length), \ 4991| | maxlen, buf, \ 4992| | prefixes[0], prefixes[1], arg, \ 4993| | &count); \ 4994| | break; \ 4995| | default: \ 4996| | abort (); \ 4997| | } 4998| |#else 4999| 484k|# define SNPRINTF_BUF(arg) \ 5000| 484k| switch (prefix_count) \ 5001| 484k| { \ 5002| 484k| case 0: \ 5003| 484k| count = sprintf (tmp, buf, arg); \ 5004| 484k| break; \ 5005| 484k| case 1: \ 5006| 484k| count = sprintf (tmp, buf, prefixes[0], arg); \ 5007| 484k| break; \ 5008| 484k| case 2: \ 5009| 484k| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ 5010| 484k| arg); \ 5011| 484k| break; \ 5012| 484k| default: \ 5013| 484k| abort (); \ 5014| 484k| } 5015| 484k|#endif 5016| | 5017| 484k| errno = 0; 5018| 484k| switch (type) 5019| 484k| { 5020| 0| case TYPE_SCHAR: ------------------ | Branch (5020:23): [True: 0, False: 484k] ------------------ 5021| 0| { 5022| 0| int arg = a.arg[dp->arg_index].a.a_schar; 5023| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5024| 0| } 5025| 0| break; 5026| 0| case TYPE_UCHAR: ------------------ | Branch (5026:23): [True: 0, False: 484k] ------------------ 5027| 0| { 5028| 0| unsigned int arg = a.arg[dp->arg_index].a.a_uchar; 5029| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5030| 0| } 5031| 0| break; 5032| 0| case TYPE_SHORT: ------------------ | Branch (5032:23): [True: 0, False: 484k] ------------------ 5033| 0| { 5034| 0| int arg = a.arg[dp->arg_index].a.a_short; 5035| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5036| 0| } 5037| 0| break; 5038| 0| case TYPE_USHORT: ------------------ | Branch (5038:23): [True: 0, False: 484k] ------------------ 5039| 0| { 5040| 0| unsigned int arg = a.arg[dp->arg_index].a.a_ushort; 5041| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5042| 0| } 5043| 0| break; 5044| 0| case TYPE_INT: ------------------ | Branch (5044:23): [True: 0, False: 484k] ------------------ 5045| 0| { 5046| 0| int arg = a.arg[dp->arg_index].a.a_int; 5047| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5048| 0| } 5049| 0| break; 5050| 327k| case TYPE_UINT: ------------------ | Branch (5050:23): [True: 327k, False: 156k] ------------------ 5051| 327k| { 5052| 327k| unsigned int arg = a.arg[dp->arg_index].a.a_uint; 5053| 327k| SNPRINTF_BUF (arg); ------------------ | | 5000| 327k| switch (prefix_count) \ | | 5001| 327k| { \ | | 5002| 327k| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 327k, False: 0] | | ------------------ | | 5003| 327k| count = sprintf (tmp, buf, arg); \ | | 5004| 327k| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 327k] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 327k] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 327k] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 327k| } ------------------ 5054| 327k| } 5055| 0| break; 5056| 0| case TYPE_LONGINT: ------------------ | Branch (5056:23): [True: 0, False: 484k] ------------------ 5057| 0| { 5058| 0| long int arg = a.arg[dp->arg_index].a.a_longint; 5059| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5060| 0| } 5061| 0| break; 5062| 9.27k| case TYPE_ULONGINT: ------------------ | Branch (5062:23): [True: 9.27k, False: 474k] ------------------ 5063| 9.27k| { 5064| 9.27k| unsigned long int arg = a.arg[dp->arg_index].a.a_ulongint; 5065| 9.27k| SNPRINTF_BUF (arg); ------------------ | | 5000| 9.27k| switch (prefix_count) \ | | 5001| 9.27k| { \ | | 5002| 9.27k| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 9.27k, False: 0] | | ------------------ | | 5003| 9.27k| count = sprintf (tmp, buf, arg); \ | | 5004| 9.27k| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 9.27k] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 9.27k] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 9.27k] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 9.27k| } ------------------ 5066| 9.27k| } 5067| 0| break; 5068| 0|#if HAVE_LONG_LONG 5069| 0| case TYPE_LONGLONGINT: ------------------ | Branch (5069:23): [True: 0, False: 484k] ------------------ 5070| 0| { 5071| 0| long long int arg = a.arg[dp->arg_index].a.a_longlongint; 5072| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5073| 0| } 5074| 0| break; 5075| 0| case TYPE_ULONGLONGINT: ------------------ | Branch (5075:23): [True: 0, False: 484k] ------------------ 5076| 0| { 5077| 0| unsigned long long int arg = a.arg[dp->arg_index].a.a_ulonglongint; 5078| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5079| 0| } 5080| 0| break; 5081| 0|#endif 5082| 0| case TYPE_DOUBLE: ------------------ | Branch (5082:23): [True: 0, False: 484k] ------------------ 5083| 0| { 5084| 0| double arg = a.arg[dp->arg_index].a.a_double; 5085| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5086| 0| } 5087| 0| break; 5088| 0| case TYPE_LONGDOUBLE: ------------------ | Branch (5088:23): [True: 0, False: 484k] ------------------ 5089| 0| { 5090| 0| long double arg = a.arg[dp->arg_index].a.a_longdouble; 5091| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5092| 0| } 5093| 0| break; 5094| 0| case TYPE_CHAR: ------------------ | Branch (5094:23): [True: 0, False: 484k] ------------------ 5095| 0| { 5096| 0| int arg = a.arg[dp->arg_index].a.a_char; 5097| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5098| 0| } 5099| 0| break; 5100| 0|#if HAVE_WINT_T 5101| 0| case TYPE_WIDE_CHAR: ------------------ | Branch (5101:23): [True: 0, False: 484k] ------------------ 5102| 0| { 5103| 0| wint_t arg = a.arg[dp->arg_index].a.a_wide_char; 5104| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5105| 0| } 5106| 0| break; 5107| 0|#endif 5108| 146k| case TYPE_STRING: ------------------ | Branch (5108:23): [True: 146k, False: 337k] ------------------ 5109| 146k| { 5110| 146k| const char *arg = a.arg[dp->arg_index].a.a_string; 5111| 146k| SNPRINTF_BUF (arg); ------------------ | | 5000| 146k| switch (prefix_count) \ | | 5001| 146k| { \ | | 5002| 146k| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 146k, False: 0] | | ------------------ | | 5003| 146k| count = sprintf (tmp, buf, arg); \ | | 5004| 146k| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 146k] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 146k] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 146k] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 146k| } ------------------ 5112| 146k| } 5113| 0| break; 5114| 0|#if HAVE_WCHAR_T 5115| 0| case TYPE_WIDE_STRING: ------------------ | Branch (5115:23): [True: 0, False: 484k] ------------------ 5116| 0| { 5117| 0| const wchar_t *arg = a.arg[dp->arg_index].a.a_wide_string; 5118| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5119| 0| } 5120| 0| break; 5121| 0|#endif 5122| 0| case TYPE_POINTER: ------------------ | Branch (5122:23): [True: 0, False: 484k] ------------------ 5123| 0| { 5124| 0| void *arg = a.arg[dp->arg_index].a.a_pointer; 5125| 0| SNPRINTF_BUF (arg); ------------------ | | 5000| 0| switch (prefix_count) \ | | 5001| 0| { \ | | 5002| 0| case 0: \ | | ------------------ | | | Branch (5002:23): [True: 0, False: 0] | | ------------------ | | 5003| 0| count = sprintf (tmp, buf, arg); \ | | 5004| 0| break; \ | | 5005| 0| case 1: \ | | ------------------ | | | Branch (5005:23): [True: 0, False: 0] | | ------------------ | | 5006| 0| count = sprintf (tmp, buf, prefixes[0], arg); \ | | 5007| 0| break; \ | | 5008| 0| case 2: \ | | ------------------ | | | Branch (5008:23): [True: 0, False: 0] | | ------------------ | | 5009| 0| count = sprintf (tmp, buf, prefixes[0], prefixes[1],\ | | 5010| 0| arg); \ | | 5011| 0| break; \ | | 5012| 0| default: \ | | ------------------ | | | Branch (5012:23): [True: 0, False: 0] | | ------------------ | | 5013| 0| abort (); \ | | 5014| 0| } ------------------ 5126| 0| } 5127| 0| break; 5128| 0| default: ------------------ | Branch (5128:23): [True: 0, False: 484k] ------------------ 5129| 0| abort (); 5130| 484k| } 5131| | 5132| |#if USE_SNPRINTF 5133| | /* Portability: Not all implementations of snprintf() 5134| | are ISO C 99 compliant. Determine the number of 5135| | bytes that snprintf() has produced or would have 5136| | produced. */ 5137| | if (count >= 0) 5138| | { 5139| | /* Verify that snprintf() has NUL-terminated its 5140| | result. */ 5141| | if ((unsigned int) count < maxlen 5142| | && ((TCHAR_T *) (result + length)) [count] != '\0') 5143| | abort (); 5144| | /* Portability hack. */ 5145| | if (retcount > count) 5146| | count = retcount; 5147| | } 5148| | else 5149| | { 5150| | /* snprintf() doesn't understand the '%n' 5151| | directive. */ 5152| | if (fbp[1] != '\0') 5153| | { 5154| | /* Don't use the '%n' directive; instead, look 5155| | at the snprintf() return value. */ 5156| | fbp[1] = '\0'; 5157| | continue; 5158| | } 5159| | else 5160| | { 5161| | /* Look at the snprintf() return value. */ 5162| | if (retcount < 0) 5163| | { 5164| |# if !HAVE_SNPRINTF_RETVAL_C99 || USE_MSVC__SNPRINTF 5165| | /* HP-UX 10.20 snprintf() is doubly deficient: 5166| | It doesn't understand the '%n' directive, 5167| | *and* it returns -1 (rather than the length 5168| | that would have been required) when the 5169| | buffer is too small. 5170| | But a failure at this point can also come 5171| | from other reasons than a too small buffer, 5172| | such as an invalid wide string argument to 5173| | the %ls directive, or possibly an invalid 5174| | floating-point argument. */ 5175| | size_t tmp_length = 5176| | MAX_ROOM_NEEDED (&a, dp->arg_index, 5177| | dp->conversion, type, flags, 5178| | width, 5179| | has_precision, 5180| | precision, pad_ourselves); 5181| | 5182| | if (maxlen < tmp_length) 5183| | { 5184| | /* Make more room. But try to do through 5185| | this reallocation only once. */ 5186| | size_t bigger_need = 5187| | xsum (length, 5188| | xsum (tmp_length, 5189| | TCHARS_PER_DCHAR - 1) 5190| | / TCHARS_PER_DCHAR); 5191| | /* And always grow proportionally. 5192| | (There may be several arguments, each 5193| | needing a little more room than the 5194| | previous one.) */ 5195| | size_t bigger_need2 = 5196| | xsum (xtimes (allocated, 2), 12); 5197| | if (bigger_need < bigger_need2) 5198| | bigger_need = bigger_need2; 5199| | ENSURE_ALLOCATION (bigger_need); 5200| | continue; 5201| | } 5202| |# endif 5203| | } 5204| | else 5205| | count = retcount; 5206| | } 5207| | } 5208| |#endif 5209| | 5210| | /* Attempt to handle failure. */ 5211| 484k| if (count < 0) ------------------ | Branch (5211:25): [True: 0, False: 484k] ------------------ 5212| 0| { 5213| | /* SNPRINTF or sprintf failed. Save and use the errno 5214| | that it has set, if any. */ 5215| 0| int saved_errno = errno; 5216| 0| if (saved_errno == 0) ------------------ | Branch (5216:29): [True: 0, False: 0] ------------------ 5217| 0| { 5218| 0| if (dp->conversion == 'c' || dp->conversion == 's') ------------------ | Branch (5218:33): [True: 0, False: 0] | Branch (5218:58): [True: 0, False: 0] ------------------ 5219| 0| saved_errno = EILSEQ; 5220| 0| else 5221| 0| saved_errno = EINVAL; 5222| 0| } 5223| | 5224| 0| if (!(result == resultbuf || result == NULL)) ------------------ | Branch (5224:31): [True: 0, False: 0] | Branch (5224:54): [True: 0, False: 0] ------------------ 5225| 0| free (result); ------------------ | | 35| 0|#define free g_free ------------------ 5226| 0| if (buf_malloced != NULL) ------------------ | Branch (5226:29): [True: 0, False: 0] ------------------ 5227| 0| free (buf_malloced); ------------------ | | 35| 0|#define free g_free ------------------ 5228| 0| CLEANUP (); ------------------ | | 1799| 0| if (d.dir != d.direct_alloc_dir) \ | | ------------------ | | | Branch (1799:7): [True: 0, False: 0] | | ------------------ | | 1800| 0| free (d.dir); \ | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ | | 1801| 0| if (a.arg != a.direct_alloc_arg) \ | | ------------------ | | | Branch (1801:7): [True: 0, False: 0] | | ------------------ | | 1802| 0| free (a.arg); | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ ------------------ 5229| | 5230| 0| errno = saved_errno; 5231| 0| return NULL; 5232| 0| } 5233| | 5234| |#if USE_SNPRINTF 5235| | /* Handle overflow of the allocated buffer. 5236| | If such an overflow occurs, a C99 compliant snprintf() 5237| | returns a count >= maxlen. However, a non-compliant 5238| | snprintf() function returns only count = maxlen - 1. To 5239| | cover both cases, test whether count >= maxlen - 1. */ 5240| | if ((unsigned int) count + 1 >= maxlen) 5241| | { 5242| | /* If maxlen already has attained its allowed maximum, 5243| | allocating more memory will not increase maxlen. 5244| | Instead of looping, bail out. */ 5245| | if (maxlen == INT_MAX / TCHARS_PER_DCHAR) 5246| | goto overflow; 5247| | else 5248| | { 5249| | /* Need at least (count + 1) * sizeof (TCHAR_T) 5250| | bytes. (The +1 is for the trailing NUL.) 5251| | But ask for (count + 2) * sizeof (TCHAR_T) 5252| | bytes, so that in the next round, we likely get 5253| | maxlen > (unsigned int) count + 1 5254| | and so we don't get here again. 5255| | And allocate proportionally, to avoid looping 5256| | eternally if snprintf() reports a too small 5257| | count. */ 5258| | size_t n = 5259| | xmax (xsum (length, 5260| | ((unsigned int) count + 2 5261| | + TCHARS_PER_DCHAR - 1) 5262| | / TCHARS_PER_DCHAR), 5263| | xtimes (allocated, 2)); 5264| | 5265| | ENSURE_ALLOCATION (n); 5266| | continue; 5267| | } 5268| | } 5269| |#endif 5270| | 5271| |#if NEED_PRINTF_UNBOUNDED_PRECISION 5272| | if (prec_ourselves) 5273| | { 5274| | /* Handle the precision. */ 5275| | TCHAR_T *prec_ptr = 5276| |# if USE_SNPRINTF 5277| | (TCHAR_T *) (result + length); 5278| |# else 5279| | tmp; 5280| |# endif 5281| | size_t prefix_count; 5282| | size_t move; 5283| | 5284| | prefix_count = 0; 5285| | /* Put the additional zeroes after the sign. */ 5286| | if (count >= 1 5287| | && (*prec_ptr == '-' || *prec_ptr == '+' 5288| | || *prec_ptr == ' ')) 5289| | prefix_count = 1; 5290| | /* Put the additional zeroes after the 0x prefix if 5291| | (flags & FLAG_ALT) || (dp->conversion == 'p'). */ 5292| | else if (count >= 2 5293| | && prec_ptr[0] == '0' 5294| | && (prec_ptr[1] == 'x' || prec_ptr[1] == 'X')) 5295| | prefix_count = 2; 5296| | 5297| | move = count - prefix_count; 5298| | if (precision > move) 5299| | { 5300| | /* Insert zeroes. */ 5301| | size_t insert = precision - move; 5302| | TCHAR_T *prec_end; 5303| | 5304| |# if USE_SNPRINTF 5305| | size_t n = 5306| | xsum (length, 5307| | (count + insert + TCHARS_PER_DCHAR - 1) 5308| | / TCHARS_PER_DCHAR); 5309| | length += (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR; 5310| | ENSURE_ALLOCATION (n); 5311| | length -= (count + TCHARS_PER_DCHAR - 1) / TCHARS_PER_DCHAR; 5312| | prec_ptr = (TCHAR_T *) (result + length); 5313| |# endif 5314| | 5315| | prec_end = prec_ptr + count; 5316| | prec_ptr += prefix_count; 5317| | 5318| | while (prec_end > prec_ptr) 5319| | { 5320| | prec_end--; 5321| | prec_end[insert] = prec_end[0]; 5322| | } 5323| | 5324| | prec_end += insert; 5325| | do 5326| | *--prec_end = '0'; 5327| | while (prec_end > prec_ptr); 5328| | 5329| | count += insert; 5330| | } 5331| | } 5332| |#endif 5333| | 5334| 484k|#if !USE_SNPRINTF 5335| 484k| if (count >= tmp_length) ------------------ | Branch (5335:25): [True: 0, False: 484k] ------------------ 5336| | /* tmp_length was incorrectly calculated - fix the 5337| | code above! */ 5338| 0| abort (); 5339| 484k|#endif 5340| | 5341| |#if !DCHAR_IS_TCHAR 5342| | /* Convert from TCHAR_T[] to DCHAR_T[]. */ 5343| | if (dp->conversion == 'c' || dp->conversion == 's') 5344| | { 5345| | /* type = TYPE_CHAR or TYPE_WIDE_CHAR or TYPE_STRING 5346| | TYPE_WIDE_STRING. 5347| | The result string is not certainly ASCII. */ 5348| | const TCHAR_T *tmpsrc; 5349| | DCHAR_T *tmpdst; 5350| | size_t tmpdst_len; 5351| | /* This code assumes that TCHAR_T is 'char'. */ 5352| | verify (sizeof (TCHAR_T) == 1); 5353| |# if USE_SNPRINTF 5354| | tmpsrc = (TCHAR_T *) (result + length); 5355| |# else 5356| | tmpsrc = tmp; 5357| |# endif 5358| | tmpdst = 5359| | DCHAR_CONV_FROM_ENCODING (locale_charset (), 5360| | iconveh_question_mark, 5361| | tmpsrc, count, 5362| | NULL, 5363| | NULL, &tmpdst_len); 5364| | if (tmpdst == NULL) 5365| | { 5366| | int saved_errno = errno; 5367| | if (!(result == resultbuf || result == NULL)) 5368| | free (result); 5369| | if (buf_malloced != NULL) 5370| | free (buf_malloced); 5371| | CLEANUP (); 5372| | errno = saved_errno; 5373| | return NULL; 5374| | } 5375| | ENSURE_ALLOCATION (xsum (length, tmpdst_len)); 5376| | DCHAR_CPY (result + length, tmpdst, tmpdst_len); 5377| | free (tmpdst); 5378| | count = tmpdst_len; 5379| | } 5380| | else 5381| | { 5382| | /* The result string is ASCII. 5383| | Simple 1:1 conversion. */ 5384| |# if USE_SNPRINTF 5385| | /* If sizeof (DCHAR_T) == sizeof (TCHAR_T), it's a 5386| | no-op conversion, in-place on the array starting 5387| | at (result + length). */ 5388| | if (sizeof (DCHAR_T) != sizeof (TCHAR_T)) 5389| |# endif 5390| | { 5391| | const TCHAR_T *tmpsrc; 5392| | DCHAR_T *tmpdst; 5393| | size_t n; 5394| | 5395| |# if USE_SNPRINTF 5396| | if (result == resultbuf) 5397| | { 5398| | tmpsrc = (TCHAR_T *) (result + length); 5399| | /* ENSURE_ALLOCATION will not move tmpsrc 5400| | (because it's part of resultbuf). */ 5401| | ENSURE_ALLOCATION (xsum (length, count)); 5402| | } 5403| | else 5404| | { 5405| | /* ENSURE_ALLOCATION will move the array 5406| | (because it uses realloc(). */ 5407| | ENSURE_ALLOCATION (xsum (length, count)); 5408| | tmpsrc = (TCHAR_T *) (result + length); 5409| | } 5410| |# else 5411| | tmpsrc = tmp; 5412| | ENSURE_ALLOCATION (xsum (length, count)); 5413| |# endif 5414| | tmpdst = result + length; 5415| | /* Copy backwards, because of overlapping. */ 5416| | tmpsrc += count; 5417| | tmpdst += count; 5418| | for (n = count; n > 0; n--) 5419| | *--tmpdst = *--tmpsrc; 5420| | } 5421| | } 5422| |#endif 5423| | 5424| 484k|#if DCHAR_IS_TCHAR && !USE_SNPRINTF 5425| | /* Make room for the result. */ 5426| 484k| if (count > allocated - length) ------------------ | Branch (5426:25): [True: 168k, False: 315k] ------------------ 5427| 168k| { 5428| | /* Need at least count elements. But allocate 5429| | proportionally. */ 5430| 168k| size_t n = 5431| 168k| xmax (xsum (length, count), xtimes (allocated, 2)); ------------------ | | 108| 168k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 168k|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 168k|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | ------------------ | | | | 84| 168k|#define G_MAXSIZE G_MAXULONG | | | | ------------------ | | | | | | 38| 168k|#define G_MAXULONG ULONG_MAX | | | | ------------------ | | ------------------ | | | Branch (108:4): [True: 168k, False: 0] | | ------------------ ------------------ 5432| | 5433| 168k| ENSURE_ALLOCATION (n); ------------------ | | 1863| 168k| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 168k, False: 0] | | ------------------ | | 1864| 168k| { \ | | 1865| 168k| size_t memory_size; \ | | 1866| 168k| DCHAR_T *memory; \ | | ------------------ | | | | 147| 168k|# define DCHAR_T char | | ------------------ | | 1867| 168k| \ | | 1868| 168k| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 168k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 168k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 168k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 168k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 168k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 168k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 168k, False: 339] | | ------------------ | | 1869| 168k| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 646, False: 167k] | | ------------------ | | 1870| 168k| allocated = (needed); \ | | 1871| 168k| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 168k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 168k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 168k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 168k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 168k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 168k, False: 0] | | | | ------------------ | | ------------------ | | 1872| 168k| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 168k| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 168k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 168k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 168k] | | | | ------------------ | | ------------------ | | 1873| 168k| goto out_of_memory; \ | | 1874| 168k| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 339, False: 168k] | | | Branch (1874:36): [True: 0, False: 168k] | | ------------------ | | 1875| 168k| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 339|#define malloc g_malloc | | ------------------ | | 1876| 168k| else \ | | 1877| 168k| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 168k|#define realloc g_realloc | | ------------------ | | 1878| 168k| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 168k] | | ------------------ | | 1879| 168k| goto out_of_memory; \ | | 1880| 168k| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 339, False: 168k] | | | Branch (1880:36): [True: 0, False: 339] | | ------------------ | | 1881| 168k| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 168k| result = memory; \ | | 1883| 168k| } ------------------ 5434| 168k| } 5435| 484k|#endif 5436| | 5437| | /* Here count <= allocated - length. */ 5438| | 5439| | /* Perform padding. */ 5440| |#if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO || NEED_PRINTF_FLAG_LEFTADJUST || NEED_PRINTF_FLAG_ZERO || NEED_PRINTF_UNBOUNDED_PRECISION 5441| | if (pad_ourselves && has_width) 5442| | { 5443| | size_t w; 5444| |# if ENABLE_UNISTDIO 5445| | /* Outside POSIX, it's preferable to compare the width 5446| | against the number of _characters_ of the converted 5447| | value. */ 5448| | w = DCHAR_MBSNLEN (result + length, count); 5449| |# else 5450| | /* The width is compared against the number of _bytes_ 5451| | of the converted value, says POSIX. */ 5452| | w = count; 5453| |# endif 5454| | if (w < width) 5455| | { 5456| | size_t pad = width - w; 5457| | 5458| | /* Make room for the result. */ 5459| | if (xsum (count, pad) > allocated - length) 5460| | { 5461| | /* Need at least count + pad elements. But 5462| | allocate proportionally. */ 5463| | size_t n = 5464| | xmax (xsum3 (length, count, pad), 5465| | xtimes (allocated, 2)); 5466| | 5467| |# if USE_SNPRINTF 5468| | length += count; 5469| | ENSURE_ALLOCATION (n); 5470| | length -= count; 5471| |# else 5472| | ENSURE_ALLOCATION (n); 5473| |# endif 5474| | } 5475| | /* Here count + pad <= allocated - length. */ 5476| | 5477| | { 5478| |# if !DCHAR_IS_TCHAR || USE_SNPRINTF 5479| | DCHAR_T * const rp = result + length; 5480| |# else 5481| | DCHAR_T * const rp = tmp; 5482| |# endif 5483| | DCHAR_T *p = rp + count; 5484| | DCHAR_T *end = p + pad; 5485| | DCHAR_T *pad_ptr; 5486| |# if !DCHAR_IS_TCHAR || ENABLE_UNISTDIO 5487| | if (dp->conversion == 'c' 5488| | || dp->conversion == 's') 5489| | /* No zero-padding for string directives. */ 5490| | pad_ptr = NULL; 5491| | else 5492| |# endif 5493| | { 5494| | pad_ptr = (*rp == '-' ? rp + 1 : rp); 5495| | /* No zero-padding of "inf" and "nan". */ 5496| | if ((*pad_ptr >= 'A' && *pad_ptr <= 'Z') 5497| | || (*pad_ptr >= 'a' && *pad_ptr <= 'z')) 5498| | pad_ptr = NULL; 5499| | } 5500| | /* The generated string now extends from rp to p, 5501| | with the zero padding insertion point being at 5502| | pad_ptr. */ 5503| | 5504| | count = count + pad; /* = end - rp */ 5505| | 5506| | if (flags & FLAG_LEFT) 5507| | { 5508| | /* Pad with spaces on the right. */ 5509| | for (; pad > 0; pad--) 5510| | *p++ = ' '; 5511| | } 5512| | else if ((flags & FLAG_ZERO) && pad_ptr != NULL) 5513| | { 5514| | /* Pad with zeroes. */ 5515| | DCHAR_T *q = end; 5516| | 5517| | while (p > pad_ptr) 5518| | *--q = *--p; 5519| | for (; pad > 0; pad--) 5520| | *p++ = '0'; 5521| | } 5522| | else 5523| | { 5524| | /* Pad with spaces on the left. */ 5525| | DCHAR_T *q = end; 5526| | 5527| | while (p > rp) 5528| | *--q = *--p; 5529| | for (; pad > 0; pad--) 5530| | *p++ = ' '; 5531| | } 5532| | } 5533| | } 5534| | } 5535| |#endif 5536| | 5537| | /* Here still count <= allocated - length. */ 5538| | 5539| |#if !DCHAR_IS_TCHAR || USE_SNPRINTF 5540| | /* The snprintf() result did fit. */ 5541| |#else 5542| | /* Append the sprintf() result. */ 5543| 484k| memcpy (result + length, tmp, count * sizeof (DCHAR_T)); 5544| 484k|#endif 5545| 484k|#if !USE_SNPRINTF 5546| 484k| if (tmp != tmpbuf) ------------------ | Branch (5546:25): [True: 0, False: 484k] ------------------ 5547| 0| free (tmp); ------------------ | | 35| 0|#define free g_free ------------------ 5548| 484k|#endif 5549| | 5550| |#if NEED_PRINTF_DIRECTIVE_F 5551| | if (dp->conversion == 'F') 5552| | { 5553| | /* Convert the %f result to upper case for %F. */ 5554| | DCHAR_T *rp = result + length; 5555| | size_t rc; 5556| | for (rc = count; rc > 0; rc--, rp++) 5557| | if (*rp >= 'a' && *rp <= 'z') 5558| | *rp = *rp - 'a' + 'A'; 5559| | } 5560| |#endif 5561| | 5562| 484k| length += count; 5563| 484k| break; 5564| 484k| } 5565| 484k| errno = orig_errno; 5566| 484k|#undef pad_ourselves 5567| 484k|#undef prec_ourselves 5568| 484k| } 5569| 484k| } 5570| 484k| } 5571| | 5572| | /* Add the final NUL. */ 5573| 257k| ENSURE_ALLOCATION (xsum (length, 1)); ------------------ | | 1863| 257k| if ((needed) > allocated) \ | | ------------------ | | | Branch (1863:9): [True: 65.4k, False: 192k] | | ------------------ | | 1864| 257k| { \ | | 1865| 65.4k| size_t memory_size; \ | | 1866| 65.4k| DCHAR_T *memory; \ | | ------------------ | | | | 147| 65.4k|# define DCHAR_T char | | ------------------ | | 1867| 65.4k| \ | | 1868| 65.4k| allocated = (allocated > 0 ? xtimes (allocated, 2) : 12); \ | | ------------------ | | | | 108| 65.4k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 65.4k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 65.4k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 65.4k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 65.4k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 65.4k, False: 0] | | | | ------------------ | | ------------------ | | | Branch (1868:22): [True: 65.4k, False: 0] | | ------------------ | | 1869| 65.4k| if ((needed) > allocated) \ | | ------------------ | | | Branch (1869:13): [True: 0, False: 65.4k] | | ------------------ | | 1870| 65.4k| allocated = (needed); \ | | 1871| 65.4k| memory_size = xtimes (allocated, sizeof (DCHAR_T)); \ | | ------------------ | | | | 108| 65.4k| ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 65.4k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 65.4k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | ((N) <= G_MAXSIZE / (ELSIZE) ? (size_t) (N) * (ELSIZE) : G_MAXSIZE) | | | | ------------------ | | | | | | 84| 65.4k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 65.4k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (108:4): [True: 65.4k, False: 0] | | | | ------------------ | | ------------------ | | 1872| 65.4k| if (size_overflow_p (memory_size)) \ | | ------------------ | | | | 112| 65.4k| ((SIZE) == G_MAXSIZE) | | | | ------------------ | | | | | | 84| 65.4k|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 65.4k|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (112:3): [True: 0, False: 65.4k] | | | | ------------------ | | ------------------ | | 1873| 65.4k| goto out_of_memory; \ | | 1874| 65.4k| if (result == resultbuf || result == NULL) \ | | ------------------ | | | Branch (1874:13): [True: 0, False: 65.4k] | | | Branch (1874:36): [True: 0, False: 65.4k] | | ------------------ | | 1875| 65.4k| memory = (DCHAR_T *) malloc (memory_size); \ | | ------------------ | | | | 33| 0|#define malloc g_malloc | | ------------------ | | 1876| 65.4k| else \ | | 1877| 65.4k| memory = (DCHAR_T *) realloc (result, memory_size); \ | | ------------------ | | | | 34| 65.4k|#define realloc g_realloc | | ------------------ | | 1878| 65.4k| if (memory == NULL) \ | | ------------------ | | | Branch (1878:13): [True: 0, False: 65.4k] | | ------------------ | | 1879| 65.4k| goto out_of_memory; \ | | 1880| 65.4k| if (result == resultbuf && length > 0) \ | | ------------------ | | | Branch (1880:13): [True: 0, False: 65.4k] | | | Branch (1880:36): [True: 0, False: 0] | | ------------------ | | 1881| 65.4k| DCHAR_CPY (memory, result, length); \ | | ------------------ | | | | 153| 0|# define DCHAR_CPY memcpy | | ------------------ | | 1882| 65.4k| result = memory; \ | | 1883| 65.4k| } ------------------ 5574| 257k| result[length] = '\0'; 5575| | 5576| 257k| if (result != resultbuf && length + 1 < allocated) ------------------ | Branch (5576:9): [True: 257k, False: 0] | Branch (5576:32): [True: 228k, False: 28.5k] ------------------ 5577| 228k| { 5578| | /* Shrink the allocated memory if possible. */ 5579| 228k| DCHAR_T *memory; ------------------ | | 147| 228k|# define DCHAR_T char ------------------ 5580| | 5581| 228k| memory = (DCHAR_T *) realloc (result, (length + 1) * sizeof (DCHAR_T)); ------------------ | | 34| 228k|#define realloc g_realloc ------------------ 5582| 228k| if (memory != NULL) ------------------ | Branch (5582:13): [True: 228k, False: 0] ------------------ 5583| 228k| result = memory; 5584| 228k| } 5585| | 5586| 257k| if (buf_malloced != NULL) ------------------ | Branch (5586:9): [True: 257k, False: 0] ------------------ 5587| 257k| free (buf_malloced); ------------------ | | 35| 257k|#define free g_free ------------------ 5588| 257k| CLEANUP (); ------------------ | | 1799| 257k| if (d.dir != d.direct_alloc_dir) \ | | ------------------ | | | Branch (1799:7): [True: 339, False: 257k] | | ------------------ | | 1800| 257k| free (d.dir); \ | | ------------------ | | | | 35| 339|#define free g_free | | ------------------ | | 1801| 257k| if (a.arg != a.direct_alloc_arg) \ | | ------------------ | | | Branch (1801:7): [True: 339, False: 257k] | | ------------------ | | 1802| 257k| free (a.arg); | | ------------------ | | | | 35| 339|#define free g_free | | ------------------ ------------------ 5589| 257k| *lengthp = length; 5590| | /* Note that we can produce a big string of a length > INT_MAX. POSIX 5591| | says that snprintf() fails with errno = EOVERFLOW in this case, but 5592| | that's only because snprintf() returns an 'int'. This function does 5593| | not have this limitation. */ 5594| 257k| return result; 5595| | 5596| |#if USE_SNPRINTF 5597| | overflow: 5598| | if (!(result == resultbuf || result == NULL)) 5599| | free (result); 5600| | if (buf_malloced != NULL) 5601| | free (buf_malloced); 5602| | CLEANUP (); 5603| | errno = EOVERFLOW; 5604| | return NULL; 5605| |#endif 5606| | 5607| 0| out_of_memory: 5608| 0| if (!(result == resultbuf || result == NULL)) ------------------ | Branch (5608:11): [True: 0, False: 0] | Branch (5608:34): [True: 0, False: 0] ------------------ 5609| 0| free (result); ------------------ | | 35| 0|#define free g_free ------------------ 5610| 0| if (buf_malloced != NULL) ------------------ | Branch (5610:9): [True: 0, False: 0] ------------------ 5611| 0| free (buf_malloced); ------------------ | | 35| 0|#define free g_free ------------------ 5612| 0| out_of_memory_1: 5613| 0| CLEANUP (); ------------------ | | 1799| 0| if (d.dir != d.direct_alloc_dir) \ | | ------------------ | | | Branch (1799:7): [True: 0, False: 0] | | ------------------ | | 1800| 0| free (d.dir); \ | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ | | 1801| 0| if (a.arg != a.direct_alloc_arg) \ | | ------------------ | | | Branch (1801:7): [True: 0, False: 0] | | ------------------ | | 1802| 0| free (a.arg); | | ------------------ | | | | 35| 0|#define free g_free | | ------------------ ------------------ 5614| 0| errno = ENOMEM; 5615| | return NULL; 5616| 0| } 5617| 0|} vasnprintf.c:max_room_needed: 1552| 484k|{ 1553| 484k| size_t tmp_length; 1554| | 1555| 484k| switch (conversion) 1556| 484k| { 1557| 232k| case 'd': case 'i': case 'u': ------------------ | Branch (1557:5): [True: 0, False: 484k] | Branch (1557:15): [True: 0, False: 484k] | Branch (1557:25): [True: 232k, False: 251k] ------------------ 1558| 232k|# if HAVE_LONG_LONG 1559| 232k| if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT) ------------------ | Branch (1559:11): [True: 0, False: 232k] | Branch (1559:39): [True: 0, False: 232k] ------------------ 1560| 0| tmp_length = 1561| 0| (unsigned int) (sizeof (unsigned long long) * CHAR_BIT 1562| 0| * 0.30103 /* binary -> decimal */ 1563| 0| ) 1564| 0| + 1; /* turn floor into ceil */ 1565| 232k| else 1566| 232k|# endif 1567| 232k| if (type == TYPE_LONGINT || type == TYPE_ULONGINT) ------------------ | Branch (1567:11): [True: 0, False: 232k] | Branch (1567:35): [True: 9.27k, False: 223k] ------------------ 1568| 9.27k| tmp_length = 1569| 9.27k| (unsigned int) (sizeof (unsigned long) * CHAR_BIT 1570| 9.27k| * 0.30103 /* binary -> decimal */ 1571| 9.27k| ) 1572| 9.27k| + 1; /* turn floor into ceil */ 1573| 223k| else 1574| 223k| tmp_length = 1575| 223k| (unsigned int) (sizeof (unsigned int) * CHAR_BIT 1576| 223k| * 0.30103 /* binary -> decimal */ 1577| 223k| ) 1578| 223k| + 1; /* turn floor into ceil */ 1579| 232k| if (tmp_length < precision) ------------------ | Branch (1579:11): [True: 0, False: 232k] ------------------ 1580| 0| tmp_length = precision; 1581| | /* Multiply by 2, as an estimate for FLAG_GROUP. */ 1582| 232k| tmp_length = xsum (tmp_length, tmp_length); 1583| | /* Add 1, to account for a leading sign. */ 1584| 232k| tmp_length = xsum (tmp_length, 1); 1585| 232k| break; 1586| | 1587| 0| case 'o': ------------------ | Branch (1587:5): [True: 0, False: 484k] ------------------ 1588| 0|# if HAVE_LONG_LONG 1589| 0| if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT) ------------------ | Branch (1589:11): [True: 0, False: 0] | Branch (1589:39): [True: 0, False: 0] ------------------ 1590| 0| tmp_length = 1591| 0| (unsigned int) (sizeof (unsigned long long) * CHAR_BIT 1592| 0| * 0.333334 /* binary -> octal */ 1593| 0| ) 1594| 0| + 1; /* turn floor into ceil */ 1595| 0| else 1596| 0|# endif 1597| 0| if (type == TYPE_LONGINT || type == TYPE_ULONGINT) ------------------ | Branch (1597:11): [True: 0, False: 0] | Branch (1597:35): [True: 0, False: 0] ------------------ 1598| 0| tmp_length = 1599| 0| (unsigned int) (sizeof (unsigned long) * CHAR_BIT 1600| 0| * 0.333334 /* binary -> octal */ 1601| 0| ) 1602| 0| + 1; /* turn floor into ceil */ 1603| 0| else 1604| 0| tmp_length = 1605| 0| (unsigned int) (sizeof (unsigned int) * CHAR_BIT 1606| 0| * 0.333334 /* binary -> octal */ 1607| 0| ) 1608| 0| + 1; /* turn floor into ceil */ 1609| 0| if (tmp_length < precision) ------------------ | Branch (1609:11): [True: 0, False: 0] ------------------ 1610| 0| tmp_length = precision; 1611| | /* Add 1, to account for a leading sign. */ 1612| 0| tmp_length = xsum (tmp_length, 1); 1613| 0| break; 1614| | 1615| 104k| case 'x': case 'X': ------------------ | Branch (1615:5): [True: 104k, False: 379k] | Branch (1615:15): [True: 0, False: 484k] ------------------ 1616| 104k|# if HAVE_LONG_LONG 1617| 104k| if (type == TYPE_LONGLONGINT || type == TYPE_ULONGLONGINT) ------------------ | Branch (1617:11): [True: 0, False: 104k] | Branch (1617:39): [True: 0, False: 104k] ------------------ 1618| 0| tmp_length = 1619| 0| (unsigned int) (sizeof (unsigned long long) * CHAR_BIT 1620| 0| * 0.25 /* binary -> hexadecimal */ 1621| 0| ) 1622| 0| + 1; /* turn floor into ceil */ 1623| 104k| else 1624| 104k|# endif 1625| 104k| if (type == TYPE_LONGINT || type == TYPE_ULONGINT) ------------------ | Branch (1625:11): [True: 0, False: 104k] | Branch (1625:35): [True: 0, False: 104k] ------------------ 1626| 0| tmp_length = 1627| 0| (unsigned int) (sizeof (unsigned long) * CHAR_BIT 1628| 0| * 0.25 /* binary -> hexadecimal */ 1629| 0| ) 1630| 0| + 1; /* turn floor into ceil */ 1631| 104k| else 1632| 104k| tmp_length = 1633| 104k| (unsigned int) (sizeof (unsigned int) * CHAR_BIT 1634| 104k| * 0.25 /* binary -> hexadecimal */ 1635| 104k| ) 1636| 104k| + 1; /* turn floor into ceil */ 1637| 104k| if (tmp_length < precision) ------------------ | Branch (1637:11): [True: 0, False: 104k] ------------------ 1638| 0| tmp_length = precision; 1639| | /* Add 2, to account for a leading sign or alternate form. */ 1640| 104k| tmp_length = xsum (tmp_length, 2); 1641| 104k| break; 1642| | 1643| 0| case 'f': case 'F': ------------------ | Branch (1643:5): [True: 0, False: 484k] | Branch (1643:15): [True: 0, False: 484k] ------------------ 1644| 0| if (type == TYPE_LONGDOUBLE) ------------------ | Branch (1644:11): [True: 0, False: 0] ------------------ 1645| 0| tmp_length = 1646| 0| (unsigned int) (LDBL_MAX_EXP 1647| 0| * 0.30103 /* binary -> decimal */ 1648| 0| * 2 /* estimate for FLAG_GROUP */ 1649| 0| ) 1650| 0| + 1 /* turn floor into ceil */ 1651| 0| + 10; /* sign, decimal point etc. */ 1652| 0| else 1653| 0| tmp_length = 1654| 0| (unsigned int) (DBL_MAX_EXP 1655| 0| * 0.30103 /* binary -> decimal */ 1656| 0| * 2 /* estimate for FLAG_GROUP */ 1657| 0| ) 1658| 0| + 1 /* turn floor into ceil */ 1659| 0| + 10; /* sign, decimal point etc. */ 1660| 0| tmp_length = xsum (tmp_length, precision); 1661| 0| break; 1662| | 1663| 0| case 'e': case 'E': case 'g': case 'G': ------------------ | Branch (1663:5): [True: 0, False: 484k] | Branch (1663:15): [True: 0, False: 484k] | Branch (1663:25): [True: 0, False: 484k] | Branch (1663:35): [True: 0, False: 484k] ------------------ 1664| 0| tmp_length = 1665| 0| 12; /* sign, decimal point, exponent etc. */ 1666| 0| tmp_length = xsum (tmp_length, precision); 1667| 0| break; 1668| | 1669| 0| case 'a': case 'A': ------------------ | Branch (1669:5): [True: 0, False: 484k] | Branch (1669:15): [True: 0, False: 484k] ------------------ 1670| 0| if (type == TYPE_LONGDOUBLE) ------------------ | Branch (1670:11): [True: 0, False: 0] ------------------ 1671| 0| tmp_length = 1672| 0| (unsigned int) (LDBL_DIG 1673| 0| * 0.831 /* decimal -> hexadecimal */ 1674| 0| ) 1675| 0| + 1; /* turn floor into ceil */ 1676| 0| else 1677| 0| tmp_length = 1678| 0| (unsigned int) (DBL_DIG 1679| 0| * 0.831 /* decimal -> hexadecimal */ 1680| 0| ) 1681| 0| + 1; /* turn floor into ceil */ 1682| 0| if (tmp_length < precision) ------------------ | Branch (1682:11): [True: 0, False: 0] ------------------ 1683| 0| tmp_length = precision; 1684| | /* Account for sign, decimal point etc. */ 1685| 0| tmp_length = xsum (tmp_length, 12); 1686| 0| break; 1687| | 1688| 0| case 'c': ------------------ | Branch (1688:5): [True: 0, False: 484k] ------------------ 1689| 0|# if HAVE_WINT_T && !WIDE_CHAR_VERSION 1690| 0| if (type == TYPE_WIDE_CHAR) ------------------ | Branch (1690:11): [True: 0, False: 0] ------------------ 1691| 0| tmp_length = MB_CUR_MAX; 1692| 0| else 1693| 0|# endif 1694| 0| tmp_length = 1; 1695| 0| break; 1696| | 1697| 146k| case 's': ------------------ | Branch (1697:5): [True: 146k, False: 337k] ------------------ 1698| 146k|# if HAVE_WCHAR_T 1699| 146k| if (type == TYPE_WIDE_STRING) ------------------ | Branch (1699:11): [True: 0, False: 146k] ------------------ 1700| 0| { 1701| |# if WIDE_CHAR_VERSION 1702| | /* ISO C says about %ls in fwprintf: 1703| | "If the precision is not specified or is greater than the size 1704| | of the array, the array shall contain a null wide character." 1705| | So if there is a precision, we must not use wcslen. */ 1706| | const wchar_t *arg = ap->arg[arg_index].a.a_wide_string; 1707| | 1708| | if (has_precision) 1709| | tmp_length = local_wcsnlen (arg, precision); 1710| | else 1711| | tmp_length = local_wcslen (arg); 1712| |# else 1713| | /* ISO C says about %ls in fprintf: 1714| | "If a precision is specified, no more than that many bytes are 1715| | written (including shift sequences, if any), and the array 1716| | shall contain a null wide character if, to equal the multibyte 1717| | character sequence length given by the precision, the function 1718| | would need to access a wide character one past the end of the 1719| | array." 1720| | So if there is a precision, we must not use wcslen. */ 1721| | /* This case has already been handled separately in VASNPRINTF. */ 1722| 0| abort (); 1723| 0|# endif 1724| 0| } 1725| 146k| else 1726| 146k|# endif 1727| 146k| { 1728| |# if WIDE_CHAR_VERSION 1729| | /* ISO C says about %s in fwprintf: 1730| | "If the precision is not specified or is greater than the size 1731| | of the converted array, the converted array shall contain a 1732| | null wide character." 1733| | So if there is a precision, we must not use strlen. */ 1734| | /* This case has already been handled separately in VASNPRINTF. */ 1735| | abort (); 1736| |# else 1737| | /* ISO C says about %s in fprintf: 1738| | "If the precision is not specified or greater than the size of 1739| | the array, the array shall contain a null character." 1740| | So if there is a precision, we must not use strlen. */ 1741| 146k| const char *arg = ap->arg[arg_index].a.a_string; 1742| | 1743| 146k| if (has_precision) ------------------ | Branch (1743:15): [True: 0, False: 146k] ------------------ 1744| 0| tmp_length = local_strnlen (arg, precision); ------------------ | | 226| 0|# define local_strnlen strnlen ------------------ 1745| 146k| else 1746| 146k| tmp_length = strlen (arg); 1747| 146k|# endif 1748| 146k| } 1749| 146k| break; 1750| | 1751| 146k| case 'p': ------------------ | Branch (1751:5): [True: 0, False: 484k] ------------------ 1752| 0| tmp_length = 1753| 0| (unsigned int) (sizeof (void *) * CHAR_BIT 1754| 0| * 0.25 /* binary -> hexadecimal */ 1755| 0| ) 1756| 0| + 1 /* turn floor into ceil */ 1757| 0| + 2; /* account for leading 0x */ 1758| 0| break; 1759| | 1760| 0| default: ------------------ | Branch (1760:5): [True: 0, False: 484k] ------------------ 1761| 0| abort (); 1762| 484k| } 1763| | 1764| 484k| if (!pad_ourselves) ------------------ | Branch (1764:7): [True: 484k, False: 0] ------------------ 1765| 484k| { 1766| |# if ENABLE_UNISTDIO 1767| | /* Padding considers the number of characters, therefore the number of 1768| | elements after padding may be 1769| | > max (tmp_length, width) 1770| | but is certainly 1771| | <= tmp_length + width. */ 1772| | tmp_length = xsum (tmp_length, width); 1773| |# else 1774| | /* Padding considers the number of elements, says POSIX. */ 1775| 484k| if (tmp_length < width) ------------------ | Branch (1775:11): [True: 0, False: 484k] ------------------ 1776| 0| tmp_length = width; 1777| 484k|# endif 1778| 484k| } 1779| | 1780| 484k| tmp_length = xsum (tmp_length, 1); /* account for trailing NUL */ 1781| | 1782| 484k| return tmp_length; 1783| 484k|} xsum4: 87| 257k|{ 88| 257k| return xsum (xsum (xsum (size1, size2), size3), size4); 89| 257k|} xsum: 66| 2.82M|{ 67| 2.82M| size_t sum = size1 + size2; 68| 2.82M| return (sum >= size1 ? sum : G_MAXSIZE); ------------------ | | 84| 2.82M|#define G_MAXSIZE G_MAXULONG | | ------------------ | | | | 38| 2.82M|#define G_MAXULONG ULONG_MAX | | ------------------ ------------------ | Branch (68:11): [True: 2.82M, False: 0] ------------------ 69| 2.82M|} xmax: 97| 168k|{ 98| | /* No explicit check is needed here, because for any n: 99| | max (G_MAXSIZE, n) == G_MAXSIZE and max (n, G_MAXSIZE) == G_MAXSIZE. */ 100| 168k| return (size1 >= size2 ? size1 : size2); ------------------ | Branch (100:11): [True: 2.06k, False: 166k] ------------------ 101| 168k|} g_vasprintf: 323| 257k|{ 324| 257k| gint len; 325| 257k| g_return_val_if_fail (string != NULL, -1); ------------------ | | 643| 257k| G_STMT_START { \ | | ------------------ | | | | 874| 257k|#define G_STMT_START do | | ------------------ | | 644| 257k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 257k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 257k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 257k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 257k| int _g_boolean_var_; \ | | | | | | 1018| 257k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 257k, False: 0] | | | | | | ------------------ | | | | | | 1019| 257k| _g_boolean_var_ = 1; \ | | | | | | 1020| 257k| else \ | | | | | | 1021| 257k| _g_boolean_var_ = 0; \ | | | | | | 1022| 257k| _g_boolean_var_; \ | | | | | | 1023| 257k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 257k, False: 0] | | | | ------------------ | | ------------------ | | 645| 257k| { } \ | | 646| 257k| else \ | | 647| 257k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 257k| } G_STMT_END | | ------------------ | | | | 882| 257k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 257k] | | | | ------------------ | | ------------------ ------------------ 326| | 327| 257k|#if !defined(USE_SYSTEM_PRINTF) 328| | 329| 257k| len = _g_gnulib_vasprintf (string, format, args); 330| 257k| if (len < 0) ------------------ | Branch (330:7): [True: 0, False: 257k] ------------------ 331| 0| *string = NULL; 332| | 333| |#elif defined (HAVE_VASPRINTF) 334| | 335| | { 336| | int saved_errno; 337| | len = vasprintf (string, format, args); 338| | saved_errno = errno; 339| | if (len < 0) 340| | { 341| | if (saved_errno == ENOMEM) 342| | g_error ("%s: failed to allocate memory", G_STRLOC); 343| | else 344| | *string = NULL; 345| | } 346| | } 347| | 348| |#else 349| | 350| | { 351| | va_list args2; 352| | 353| | G_VA_COPY (args2, args); 354| | 355| | *string = g_new (gchar, g_printf_string_upper_bound (format, args)); 356| | 357| | len = _g_vsprintf (*string, format, args2); 358| | va_end (args2); 359| | } 360| |#endif 361| | 362| 257k| return len; 363| 257k|} g_quark_init: 59| 2|{ 60| 2| g_assert (quark_seq_id == 0); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 61| 2| quark_ht = g_hash_table_new (g_str_hash, g_str_equal); 62| 2| quarks = g_new (gchar*, QUARK_BLOCK_SIZE); ------------------ | | 290| 2|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 2| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2| gsize __n = (gsize) (n_structs); \ | | | | 237| 2| gsize __s = sizeof (struct_type); \ | | | | 238| 2| gpointer __p; \ | | | | 239| 2| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2] | | | | ------------------ | | | | 240| 2| __p = g_##func (__n); \ | | | | 241| 2| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 2, False: 0] | | | | ------------------ | | | | 242| 2| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 2|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 2|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 2] | | | | | Branch (242:26): [True: 2, False: 0] | | | | ------------------ | | | | 243| 2| __p = g_##func (__n * __s); \ | | | | 244| 2| else \ | | | | 245| 2| __p = g_##func##_n (__n, __s); \ | | | | 246| 2| __p; \ | | | | 247| 2| })) | | ------------------ ------------------ 63| | quarks[0] = NULL; 64| 2| quark_seq_id = 1; 65| 2|} g_quark_try_string: 137| 1|{ 138| 1| GQuark quark = 0; 139| | 140| 1| if (string == NULL) ------------------ | Branch (140:7): [True: 0, False: 1] ------------------ 141| 0| return 0; 142| | 143| 1| G_LOCK (quark_global); ------------------ | | 135| 1|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 1|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 144| 1| quark = GPOINTER_TO_UINT (g_hash_table_lookup (quark_ht, string)); ------------------ | | 99| 1|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 145| 1| G_UNLOCK (quark_global); ------------------ | | 136| 1|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 1|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 146| | 147| 1| return quark; 148| 1|} g_quark_from_string: 228| 103|{ 229| 103| return quark_from_string_locked (string, TRUE); ------------------ | | 818| 103|#define TRUE (!FALSE) | | ------------------ | | | | 814| 103|#define FALSE (0) | | ------------------ ------------------ 230| 103|} g_quark_from_static_string: 257| 15|{ 258| 15| return quark_from_string_locked (string, FALSE); ------------------ | | 814| 15|#define FALSE (0) ------------------ 259| 15|} g_quark_to_string: 271| 147|{ 272| 147| gchar* result = NULL; 273| 147| gchar **strings; 274| 147| guint seq_id; 275| | 276| 147| seq_id = (guint) g_atomic_int_get (&quark_seq_id); ------------------ | | 96| 147| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 147|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 147| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 147|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 147| gint gaig_temp; \ | | 99| 147| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 147] | | ------------------ | | 100| 147| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 147| (gint) gaig_temp; \ | | 102| 147| })) ------------------ 277| 147| strings = g_atomic_pointer_get (&quarks); ------------------ | | 113| 147| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 147|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 114| 147| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 147|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 115| 147| glib_typeof (*(atomic)) gapg_temp_newval; \ | | ------------------ | | | | 238| 147|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 116| 147| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 147|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 117| 147| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | 118| 147| gapg_temp_newval; \ | | 119| 147| })) ------------------ 278| | 279| 147| if (quark < seq_id) ------------------ | Branch (279:7): [True: 147, False: 0] ------------------ 280| 147| result = strings[quark]; 281| | 282| 147| return result; 283| 147|} g_intern_string: 349| 1|{ 350| 1| return quark_intern_string_locked (string, TRUE); ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 351| 1|} g_intern_static_string: 372| 103|{ 373| 103| return quark_intern_string_locked (string, FALSE); ------------------ | | 814| 103|#define FALSE (0) ------------------ 374| 103|} gquark.c:quark_from_string_locked: 199| 118|{ 200| 118| GQuark quark = 0; 201| | 202| 118| if (!string) ------------------ | Branch (202:7): [True: 0, False: 118] ------------------ 203| 0| return 0; 204| | 205| 118| G_LOCK (quark_global); ------------------ | | 135| 118|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 118|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 206| 118| quark = quark_from_string (string, duplicate); 207| 118| G_UNLOCK (quark_global); ------------------ | | 136| 118|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 118|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 208| | 209| 118| return quark; 210| 118|} gquark.c:quark_from_string: 182| 222|{ 183| 222| GQuark quark = 0; 184| | 185| 222| quark = GPOINTER_TO_UINT (g_hash_table_lookup (quark_ht, string)); ------------------ | | 99| 222|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 186| | 187| 222| if (!quark) ------------------ | Branch (187:7): [True: 118, False: 104] ------------------ 188| 118| { 189| 118| quark = quark_new (duplicate ? quark_strdup (string) : (gchar *)string); ------------------ | Branch (189:26): [True: 0, False: 118] ------------------ 190| 118| TRACE(GLIB_QUARK_NEW(string, quark)); 191| 118| } 192| | 193| 222| return quark; 194| 222|} gquark.c:quark_new: 288| 118|{ 289| 118| GQuark quark; 290| 118| gchar **quarks_new; 291| | 292| 118| if (quark_seq_id % QUARK_BLOCK_SIZE == 0) ------------------ | | 45| 118|#define QUARK_BLOCK_SIZE 2048 ------------------ | Branch (292:7): [True: 0, False: 118] ------------------ 293| 0| { 294| 0| quarks_new = g_new (gchar*, quark_seq_id + QUARK_BLOCK_SIZE); ------------------ | | 290| 0|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 0| gsize __n = (gsize) (n_structs); \ | | | | 237| 0| gsize __s = sizeof (struct_type); \ | | | | 238| 0| gpointer __p; \ | | | | 239| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 0] | | | | ------------------ | | | | 240| 0| __p = g_##func (__n); \ | | | | 241| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 0| __p; \ | | | | 247| 0| })) | | ------------------ ------------------ 295| 0| if (quark_seq_id != 0) ------------------ | Branch (295:11): [True: 0, False: 0] ------------------ 296| 0| memcpy (quarks_new, quarks, sizeof (char *) * quark_seq_id); 297| 0| memset (quarks_new + quark_seq_id, 0, sizeof (char *) * QUARK_BLOCK_SIZE); ------------------ | | 45| 0|#define QUARK_BLOCK_SIZE 2048 ------------------ 298| | /* This leaks the old quarks array. Its unfortunate, but it allows 299| | * us to do lockless lookup of the arrays, and there shouldn't be that 300| | * many quarks in an app 301| | */ 302| 0| g_atomic_pointer_set (&quarks, quarks_new); ------------------ | | 121| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 122| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 123| 0| glib_typeof ((atomic)) gaps_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 0|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 124| 0| glib_typeof (*(atomic)) gaps_temp_newval = (newval); \ | | ------------------ | | | | 238| 0|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 125| 0| (void) (0 ? (gpointer) * (atomic) : NULL); \ | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ | | 126| 0| __atomic_store (gaps_temp_atomic, &gaps_temp_newval, __ATOMIC_SEQ_CST); \ | | 127| 0| })) ------------------ 303| 0| } 304| | 305| 118| quark = quark_seq_id; 306| 118| g_atomic_pointer_set (&quarks[quark], string); ------------------ | | 121| 118| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 118|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 122| 118| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 118|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 123| 118| glib_typeof ((atomic)) gaps_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 118|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 124| 118| glib_typeof (*(atomic)) gaps_temp_newval = (newval); \ | | ------------------ | | | | 238| 118|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 125| 118| (void) (0 ? (gpointer) * (atomic) : NULL); \ | | ------------------ | | | Branch (125:13): [Folded, False: 118] | | ------------------ | | 126| 118| __atomic_store (gaps_temp_atomic, &gaps_temp_newval, __ATOMIC_SEQ_CST); \ | | 127| 118| })) ------------------ 307| 118| g_hash_table_insert (quark_ht, string, GUINT_TO_POINTER (quark)); ------------------ | | 102| 118|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 308| 118| g_atomic_int_inc (&quark_seq_id); ------------------ | | 148| 118| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 118|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 149| 118| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 118|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 150| 118| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (150:13): [Folded, False: 118] | | ------------------ | | 151| 118| (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ | | 152| 118| })) ------------------ 309| | 310| 118| return quark; 311| 118|} gquark.c:quark_intern_string_locked: 316| 104|{ 317| 104| const gchar *result; 318| 104| GQuark quark; 319| | 320| 104| if (!string) ------------------ | Branch (320:7): [True: 0, False: 104] ------------------ 321| 0| return NULL; 322| | 323| 104| G_LOCK (quark_global); ------------------ | | 135| 104|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 104|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 324| 104| quark = quark_from_string (string, duplicate); 325| 104| result = quarks[quark]; 326| 104| G_UNLOCK (quark_global); ------------------ | | 136| 104|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 104|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 327| | 328| 104| return result; 329| 104|} g_io_error_quark: 51| 15|q_n##_quark (void) \ 52| 15|{ \ 53| 15| static GQuark q; \ 54| 15| \ 55| 15| if G_UNLIKELY (q == 0) \ ------------------ | | 1025| 15|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 15| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 15|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 15| int _g_boolean_var_; \ | | | | 1018| 15| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 1, False: 14] | | | | ------------------ | | | | 1019| 15| _g_boolean_var_ = 1; \ | | | | 1020| 15| else \ | | | | 1021| 15| _g_boolean_var_ = 0; \ | | | | 1022| 15| _g_boolean_var_; \ | | | | 1023| 15|}) | | ------------------ | | | Branch (1025:27): [True: 1, False: 14] | | ------------------ ------------------ 56| 15| q = g_quark_from_static_string (#QN); \ 57| 15| \ 58| 15| return q; \ 59| 15|} g_number_parser_error_quark: 51| 23|q_n##_quark (void) \ 52| 23|{ \ 53| 23| static GQuark q; \ 54| 23| \ 55| 23| if G_UNLIKELY (q == 0) \ ------------------ | | 1025| 23|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 23| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 23|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 23| int _g_boolean_var_; \ | | | | 1018| 23| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 1, False: 22] | | | | ------------------ | | | | 1019| 23| _g_boolean_var_ = 1; \ | | | | 1020| 23| else \ | | | | 1021| 23| _g_boolean_var_ = 0; \ | | | | 1022| 23| _g_boolean_var_; \ | | | | 1023| 23|}) | | ------------------ | | | Branch (1025:27): [True: 1, False: 22] | | ------------------ ------------------ 56| 23| q = g_quark_from_static_string (#QN); \ 57| 23| \ 58| 23| return q; \ 59| 23|} g_ref_count_init: 93| 127k|{ 94| 127k| g_return_if_fail (rc != NULL); ------------------ | | 630| 127k| G_STMT_START { \ | | ------------------ | | | | 874| 127k|#define G_STMT_START do | | ------------------ | | 631| 127k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 127k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 127k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 127k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 127k| int _g_boolean_var_; \ | | | | | | 1018| 127k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 127k, False: 0] | | | | | | ------------------ | | | | | | 1019| 127k| _g_boolean_var_ = 1; \ | | | | | | 1020| 127k| else \ | | | | | | 1021| 127k| _g_boolean_var_ = 0; \ | | | | | | 1022| 127k| _g_boolean_var_; \ | | | | | | 1023| 127k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 127k, False: 0] | | | | ------------------ | | ------------------ | | 632| 127k| { } \ | | 633| 127k| else \ | | 634| 127k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 127k| } G_STMT_END | | ------------------ | | | | 882| 127k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 127k] | | | | ------------------ | | ------------------ ------------------ 95| | 96| | /* Non-atomic refcounting is implemented using the negative range 97| | * of signed integers: 98| | * 99| | * G_MININT Z¯< 0 > Z⁺ G_MAXINT 100| | * |----------------------------|----------------------------| 101| | * 102| | * Acquiring a reference moves us towards MININT, and releasing a 103| | * reference moves us towards 0. 104| | */ 105| 127k| *rc = -1; 106| 127k|} g_ref_count_inc: 118| 123k|{ 119| 123k| grefcount rrc; 120| | 121| 123k| g_return_if_fail (rc != NULL); ------------------ | | 630| 123k| G_STMT_START { \ | | ------------------ | | | | 874| 123k|#define G_STMT_START do | | ------------------ | | 631| 123k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 123k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 123k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 123k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 123k| int _g_boolean_var_; \ | | | | | | 1018| 123k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 123k, False: 0] | | | | | | ------------------ | | | | | | 1019| 123k| _g_boolean_var_ = 1; \ | | | | | | 1020| 123k| else \ | | | | | | 1021| 123k| _g_boolean_var_ = 0; \ | | | | | | 1022| 123k| _g_boolean_var_; \ | | | | | | 1023| 123k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 123k, False: 0] | | | | ------------------ | | ------------------ | | 632| 123k| { } \ | | 633| 123k| else \ | | 634| 123k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 123k| } G_STMT_END | | ------------------ | | | | 882| 123k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 123k] | | | | ------------------ | | ------------------ ------------------ 122| | 123| 123k| rrc = *rc; 124| | 125| 123k| g_return_if_fail (rrc < 0); ------------------ | | 630| 123k| G_STMT_START { \ | | ------------------ | | | | 874| 123k|#define G_STMT_START do | | ------------------ | | 631| 123k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 123k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 123k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 123k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 123k| int _g_boolean_var_; \ | | | | | | 1018| 123k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 123k, False: 0] | | | | | | ------------------ | | | | | | 1019| 123k| _g_boolean_var_ = 1; \ | | | | | | 1020| 123k| else \ | | | | | | 1021| 123k| _g_boolean_var_ = 0; \ | | | | | | 1022| 123k| _g_boolean_var_; \ | | | | | | 1023| 123k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 123k, False: 0] | | | | ------------------ | | ------------------ | | 632| 123k| { } \ | | 633| 123k| else \ | | 634| 123k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 123k| } G_STMT_END | | ------------------ | | | | 882| 123k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 123k] | | | | ------------------ | | ------------------ ------------------ 126| | 127| | /* Check for saturation */ 128| 123k| if (rrc == G_MININT) ------------------ | | 33| 123k|#define G_MININT INT_MIN ------------------ | Branch (128:7): [True: 0, False: 123k] ------------------ 129| 0| { 130| 0| g_critical ("Reference count %p has reached saturation", rc); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 131| 0| return; 132| 0| } 133| | 134| 123k| rrc -= 1; 135| | 136| 123k| *rc = rrc; 137| 123k|} g_ref_count_dec: 151| 250k|{ 152| 250k| grefcount rrc; 153| | 154| 250k| g_return_val_if_fail (rc != NULL, FALSE); ------------------ | | 643| 250k| G_STMT_START { \ | | ------------------ | | | | 874| 250k|#define G_STMT_START do | | ------------------ | | 644| 250k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 250k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 250k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 250k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 250k| int _g_boolean_var_; \ | | | | | | 1018| 250k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 250k, False: 0] | | | | | | ------------------ | | | | | | 1019| 250k| _g_boolean_var_ = 1; \ | | | | | | 1020| 250k| else \ | | | | | | 1021| 250k| _g_boolean_var_ = 0; \ | | | | | | 1022| 250k| _g_boolean_var_; \ | | | | | | 1023| 250k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 250k, False: 0] | | | | ------------------ | | ------------------ | | 645| 250k| { } \ | | 646| 250k| else \ | | 647| 250k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 250k| } G_STMT_END | | ------------------ | | | | 882| 250k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 250k] | | | | ------------------ | | ------------------ ------------------ 155| | 156| 250k| rrc = *rc; 157| | 158| 250k| g_return_val_if_fail (rrc < 0, FALSE); ------------------ | | 643| 250k| G_STMT_START { \ | | ------------------ | | | | 874| 250k|#define G_STMT_START do | | ------------------ | | 644| 250k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 250k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 250k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 250k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 250k| int _g_boolean_var_; \ | | | | | | 1018| 250k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 250k, False: 0] | | | | | | ------------------ | | | | | | 1019| 250k| _g_boolean_var_ = 1; \ | | | | | | 1020| 250k| else \ | | | | | | 1021| 250k| _g_boolean_var_ = 0; \ | | | | | | 1022| 250k| _g_boolean_var_; \ | | | | | | 1023| 250k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 250k, False: 0] | | | | ------------------ | | ------------------ | | 645| 250k| { } \ | | 646| 250k| else \ | | 647| 250k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 250k| } G_STMT_END | | ------------------ | | | | 882| 250k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 250k] | | | | ------------------ | | ------------------ ------------------ 159| | 160| 250k| rrc += 1; 161| 250k| if (rrc == 0) ------------------ | Branch (161:7): [True: 127k, False: 123k] ------------------ 162| 127k| return TRUE; ------------------ | | 818| 127k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 127k|#define FALSE (0) | | ------------------ ------------------ 163| | 164| 123k| *rc = rrc; 165| | 166| 123k| return FALSE; ------------------ | | 814| 123k|#define FALSE (0) ------------------ 167| 250k|} g_atomic_ref_count_init: 208| 60.8k|{ 209| 60.8k| g_return_if_fail (arc != NULL); ------------------ | | 630| 60.8k| G_STMT_START { \ | | ------------------ | | | | 874| 60.8k|#define G_STMT_START do | | ------------------ | | 631| 60.8k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 60.8k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 60.8k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 60.8k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 60.8k| int _g_boolean_var_; \ | | | | | | 1018| 60.8k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 60.8k, False: 0] | | | | | | ------------------ | | | | | | 1019| 60.8k| _g_boolean_var_ = 1; \ | | | | | | 1020| 60.8k| else \ | | | | | | 1021| 60.8k| _g_boolean_var_ = 0; \ | | | | | | 1022| 60.8k| _g_boolean_var_; \ | | | | | | 1023| 60.8k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 60.8k, False: 0] | | | | ------------------ | | ------------------ | | 632| 60.8k| { } \ | | 633| 60.8k| else \ | | 634| 60.8k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 60.8k| } G_STMT_END | | ------------------ | | | | 882| 60.8k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 60.8k] | | | | ------------------ | | ------------------ ------------------ 210| | 211| | /* Atomic refcounting is implemented using the positive range 212| | * of signed integers: 213| | * 214| | * G_MININT Z¯< 0 > Z⁺ G_MAXINT 215| | * |----------------------------|----------------------------| 216| | * 217| | * Acquiring a reference moves us towards MAXINT, and releasing a 218| | * reference moves us towards 0. 219| | */ 220| 60.8k| *arc = 1; 221| 60.8k|} g_atomic_ref_count_inc: 233| 7.86k|{ 234| 7.86k| g_return_if_fail (arc != NULL); ------------------ | | 630| 7.86k| G_STMT_START { \ | | ------------------ | | | | 874| 7.86k|#define G_STMT_START do | | ------------------ | | 631| 7.86k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.86k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.86k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.86k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.86k| int _g_boolean_var_; \ | | | | | | 1018| 7.86k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.86k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.86k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.86k| else \ | | | | | | 1021| 7.86k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.86k| _g_boolean_var_; \ | | | | | | 1023| 7.86k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.86k, False: 0] | | | | ------------------ | | ------------------ | | 632| 7.86k| { } \ | | 633| 7.86k| else \ | | 634| 7.86k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 7.86k| } G_STMT_END | | ------------------ | | | | 882| 7.86k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.86k] | | | | ------------------ | | ------------------ ------------------ 235| 7.86k| g_return_if_fail (g_atomic_int_get (arc) > 0); ------------------ | | 630| 7.86k| G_STMT_START { \ | | ------------------ | | | | 874| 7.86k|#define G_STMT_START do | | ------------------ | | 631| 7.86k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.86k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.86k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.86k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.86k| int _g_boolean_var_; \ | | | | | | 1018| 23.5k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [Folded, False: 7.86k] | | | | | | | Branch (1018:8): [True: 7.86k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.86k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.86k| else \ | | | | | | 1021| 7.86k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.86k| _g_boolean_var_; \ | | | | | | 1023| 7.86k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.86k, False: 0] | | | | ------------------ | | ------------------ | | 632| 7.86k| { } \ | | 633| 7.86k| else \ | | 634| 7.86k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 7.86k| } G_STMT_END | | ------------------ | | | | 882| 7.86k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.86k] | | | | ------------------ | | ------------------ ------------------ 236| | 237| 7.86k| if (g_atomic_int_get (arc) == G_MAXINT) ------------------ | | 96| 7.86k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.86k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 7.86k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.86k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 7.86k| gint gaig_temp; \ | | 99| 7.86k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 7.86k] | | ------------------ | | 100| 7.86k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 7.86k| (gint) gaig_temp; \ | | 102| 7.86k| })) ------------------ if (g_atomic_int_get (arc) == G_MAXINT) ------------------ | | 34| 7.86k|#define G_MAXINT INT_MAX ------------------ | Branch (237:7): [True: 0, False: 7.86k] ------------------ 238| 0| { 239| 0| g_critical ("Reference count has reached saturation"); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 240| 0| return; 241| 0| } 242| | 243| 7.86k| g_atomic_int_inc (arc); ------------------ | | 148| 7.86k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.86k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 149| 7.86k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.86k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 150| 7.86k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (150:13): [Folded, False: 7.86k] | | ------------------ | | 151| 7.86k| (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ | | 152| 7.86k| })) ------------------ 244| 7.86k|} g_atomic_ref_count_dec: 258| 68.6k|{ 259| 68.6k| g_return_val_if_fail (arc != NULL, FALSE); ------------------ | | 643| 68.6k| G_STMT_START { \ | | ------------------ | | | | 874| 68.6k|#define G_STMT_START do | | ------------------ | | 644| 68.6k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 68.6k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 68.6k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 68.6k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 68.6k| int _g_boolean_var_; \ | | | | | | 1018| 68.6k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 68.6k, False: 0] | | | | | | ------------------ | | | | | | 1019| 68.6k| _g_boolean_var_ = 1; \ | | | | | | 1020| 68.6k| else \ | | | | | | 1021| 68.6k| _g_boolean_var_ = 0; \ | | | | | | 1022| 68.6k| _g_boolean_var_; \ | | | | | | 1023| 68.6k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 68.6k, False: 0] | | | | ------------------ | | ------------------ | | 645| 68.6k| { } \ | | 646| 68.6k| else \ | | 647| 68.6k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 68.6k| } G_STMT_END | | ------------------ | | | | 882| 68.6k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 68.6k] | | | | ------------------ | | ------------------ ------------------ 260| 68.6k| g_return_val_if_fail (g_atomic_int_get (arc) > 0, FALSE); ------------------ | | 643| 68.6k| G_STMT_START { \ | | ------------------ | | | | 874| 68.6k|#define G_STMT_START do | | ------------------ | | 644| 68.6k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 68.6k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 68.6k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 68.6k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 68.6k| int _g_boolean_var_; \ | | | | | | 1018| 205k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [Folded, False: 68.6k] | | | | | | | Branch (1018:8): [True: 68.6k, False: 0] | | | | | | ------------------ | | | | | | 1019| 68.6k| _g_boolean_var_ = 1; \ | | | | | | 1020| 68.6k| else \ | | | | | | 1021| 68.6k| _g_boolean_var_ = 0; \ | | | | | | 1022| 68.6k| _g_boolean_var_; \ | | | | | | 1023| 68.6k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 68.6k, False: 0] | | | | ------------------ | | ------------------ | | 645| 68.6k| { } \ | | 646| 68.6k| else \ | | 647| 68.6k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 68.6k| } G_STMT_END | | ------------------ | | | | 882| 68.6k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 68.6k] | | | | ------------------ | | ------------------ ------------------ 261| | 262| 68.6k| return g_atomic_int_dec_and_test (arc); ------------------ | | 154| 68.6k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 68.6k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 155| 68.6k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 68.6k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 156| 68.6k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (156:13): [Folded, False: 68.6k] | | ------------------ | | 157| 68.6k| __atomic_fetch_sub ((atomic), 1, __ATOMIC_SEQ_CST) == 1; \ | | 158| 68.6k| })) ------------------ 263| 68.6k|} g_slice_alloc: 1035| 80.0k|{ 1036| 80.0k| ThreadMemory *tmem; 1037| 80.0k| gsize chunk_size; 1038| 80.0k| gpointer mem; 1039| 80.0k| guint acat; 1040| | 1041| | /* This gets the private structure for this thread. If the private 1042| | * structure does not yet exist, it is created. 1043| | * 1044| | * This has a side effect of causing GSlice to be initialised, so it 1045| | * must come first. 1046| | */ 1047| 80.0k| tmem = thread_memory_from_self (); 1048| | 1049| 80.0k| chunk_size = P2ALIGN (mem_size); ------------------ | | 207| 80.0k|#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf) ------------------ 1050| 80.0k| acat = allocator_categorize (chunk_size); 1051| 80.0k| if (G_LIKELY (acat == 1)) /* allocate through magazine layer */ ------------------ | | 1024| 80.0k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 80.0k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 80.0k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 80.0k| int _g_boolean_var_; \ | | | | 1018| 80.0k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 80.0k, False: 0] | | | | ------------------ | | | | 1019| 80.0k| _g_boolean_var_ = 1; \ | | | | 1020| 80.0k| else \ | | | | 1021| 80.0k| _g_boolean_var_ = 0; \ | | | | 1022| 80.0k| _g_boolean_var_; \ | | | | 1023| 80.0k|}) | | ------------------ | | | Branch (1024:24): [True: 80.0k, False: 0] | | ------------------ ------------------ 1052| 80.0k| { 1053| 80.0k| guint ix = SLAB_INDEX (allocator, chunk_size); ------------------ | | 199| 80.0k|#define SLAB_INDEX(al, asize) ((asize) / P2ALIGNMENT - 1) /* asize must be P2ALIGNMENT aligned */ | | ------------------ | | | | 190| 80.0k|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 1054| 80.0k| if (G_UNLIKELY (thread_memory_magazine1_is_empty (tmem, ix))) ------------------ | | 1025| 80.0k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 80.0k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 80.0k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 80.0k| int _g_boolean_var_; \ | | | | 1018| 80.0k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 2.57k, False: 77.5k] | | | | ------------------ | | | | 1019| 80.0k| _g_boolean_var_ = 1; \ | | | | 1020| 80.0k| else \ | | | | 1021| 80.0k| _g_boolean_var_ = 0; \ | | | | 1022| 80.0k| _g_boolean_var_; \ | | | | 1023| 80.0k|}) | | ------------------ | | | Branch (1025:26): [True: 2.57k, False: 77.5k] | | ------------------ ------------------ 1055| 2.57k| { 1056| 2.57k| thread_memory_swap_magazines (tmem, ix); 1057| 2.57k| if (G_UNLIKELY (thread_memory_magazine1_is_empty (tmem, ix))) ------------------ | | 1025| 2.57k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2.57k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2.57k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2.57k| int _g_boolean_var_; \ | | | | 1018| 2.57k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 168, False: 2.40k] | | | | ------------------ | | | | 1019| 2.57k| _g_boolean_var_ = 1; \ | | | | 1020| 2.57k| else \ | | | | 1021| 2.57k| _g_boolean_var_ = 0; \ | | | | 1022| 2.57k| _g_boolean_var_; \ | | | | 1023| 2.57k|}) | | ------------------ | | | Branch (1025:26): [True: 168, False: 2.40k] | | ------------------ ------------------ 1058| 168| thread_memory_magazine1_reload (tmem, ix); 1059| 2.57k| } 1060| 80.0k| mem = thread_memory_magazine1_alloc (tmem, ix); 1061| 80.0k| } 1062| 0| else if (acat == 2) /* allocate through slab allocator */ ------------------ | Branch (1062:12): [True: 0, False: 0] ------------------ 1063| 0| { 1064| 0| g_mutex_lock (&allocator->slab_mutex); 1065| 0| mem = slab_allocator_alloc_chunk (chunk_size); 1066| 0| g_mutex_unlock (&allocator->slab_mutex); 1067| 0| } 1068| 0| else /* delegate to system malloc */ 1069| 0| mem = g_malloc (mem_size); 1070| 80.0k| if (G_UNLIKELY (allocator->config.debug_blocks)) ------------------ | | 1025| 80.0k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 80.0k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 80.0k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 80.0k| int _g_boolean_var_; \ | | | | 1018| 80.0k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 80.0k] | | | | ------------------ | | | | 1019| 80.0k| _g_boolean_var_ = 1; \ | | | | 1020| 80.0k| else \ | | | | 1021| 80.0k| _g_boolean_var_ = 0; \ | | | | 1022| 80.0k| _g_boolean_var_; \ | | | | 1023| 80.0k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 80.0k] | | ------------------ ------------------ 1071| 0| smc_notify_alloc (mem, mem_size); 1072| | 1073| 80.0k| TRACE (GLIB_SLICE_ALLOC((void*)mem, mem_size)); 1074| | 1075| 80.0k| return mem; 1076| 80.0k|} g_slice_alloc0: 1094| 7.70k|{ 1095| 7.70k| gpointer mem = g_slice_alloc (mem_size); 1096| 7.70k| if (mem) ------------------ | Branch (1096:7): [True: 7.70k, False: 0] ------------------ 1097| 7.70k| memset (mem, 0, mem_size); 1098| 7.70k| return mem; 1099| 7.70k|} g_slice_free1: 1146| 72.3k|{ 1147| 72.3k| gsize chunk_size = P2ALIGN (mem_size); ------------------ | | 207| 72.3k|#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf) ------------------ 1148| 72.3k| guint acat = allocator_categorize (chunk_size); 1149| 72.3k| if (G_UNLIKELY (!mem_block)) ------------------ | | 1025| 72.3k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 72.3k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 72.3k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 72.3k| int _g_boolean_var_; \ | | | | 1018| 72.3k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 72.3k] | | | | ------------------ | | | | 1019| 72.3k| _g_boolean_var_ = 1; \ | | | | 1020| 72.3k| else \ | | | | 1021| 72.3k| _g_boolean_var_ = 0; \ | | | | 1022| 72.3k| _g_boolean_var_; \ | | | | 1023| 72.3k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 72.3k] | | ------------------ ------------------ 1150| 0| return; 1151| 72.3k| if (G_UNLIKELY (allocator->config.debug_blocks) && ------------------ | | 1025| 144k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 72.3k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 72.3k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 72.3k| int _g_boolean_var_; \ | | | | 1018| 72.3k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 72.3k] | | | | ------------------ | | | | 1019| 72.3k| _g_boolean_var_ = 1; \ | | | | 1020| 72.3k| else \ | | | | 1021| 72.3k| _g_boolean_var_ = 0; \ | | | | 1022| 72.3k| _g_boolean_var_; \ | | | | 1023| 72.3k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 72.3k] | | ------------------ ------------------ 1152| 0| !smc_notify_free (mem_block, mem_size)) ------------------ | Branch (1152:7): [True: 0, False: 0] ------------------ 1153| 0| abort(); 1154| 72.3k| if (G_LIKELY (acat == 1)) /* allocate through magazine layer */ ------------------ | | 1024| 72.3k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 72.3k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 72.3k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 72.3k| int _g_boolean_var_; \ | | | | 1018| 72.3k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 72.3k, False: 0] | | | | ------------------ | | | | 1019| 72.3k| _g_boolean_var_ = 1; \ | | | | 1020| 72.3k| else \ | | | | 1021| 72.3k| _g_boolean_var_ = 0; \ | | | | 1022| 72.3k| _g_boolean_var_; \ | | | | 1023| 72.3k|}) | | ------------------ | | | Branch (1024:24): [True: 72.3k, False: 0] | | ------------------ ------------------ 1155| 72.3k| { 1156| 72.3k| ThreadMemory *tmem = thread_memory_from_self(); 1157| 72.3k| guint ix = SLAB_INDEX (allocator, chunk_size); ------------------ | | 199| 72.3k|#define SLAB_INDEX(al, asize) ((asize) / P2ALIGNMENT - 1) /* asize must be P2ALIGNMENT aligned */ | | ------------------ | | | | 190| 72.3k|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 1158| 72.3k| if (G_UNLIKELY (thread_memory_magazine2_is_full (tmem, ix))) ------------------ | | 1025| 72.3k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 72.3k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 72.3k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 72.3k| int _g_boolean_var_; \ | | | | 1018| 72.3k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 2.08k, False: 70.2k] | | | | ------------------ | | | | 1019| 72.3k| _g_boolean_var_ = 1; \ | | | | 1020| 72.3k| else \ | | | | 1021| 72.3k| _g_boolean_var_ = 0; \ | | | | 1022| 72.3k| _g_boolean_var_; \ | | | | 1023| 72.3k|}) | | ------------------ | | | Branch (1025:26): [True: 2.08k, False: 70.2k] | | ------------------ ------------------ 1159| 2.08k| { 1160| 2.08k| thread_memory_swap_magazines (tmem, ix); 1161| 2.08k| if (G_UNLIKELY (thread_memory_magazine2_is_full (tmem, ix))) ------------------ | | 1025| 2.08k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2.08k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2.08k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2.08k| int _g_boolean_var_; \ | | | | 1018| 2.08k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 157, False: 1.92k] | | | | ------------------ | | | | 1019| 2.08k| _g_boolean_var_ = 1; \ | | | | 1020| 2.08k| else \ | | | | 1021| 2.08k| _g_boolean_var_ = 0; \ | | | | 1022| 2.08k| _g_boolean_var_; \ | | | | 1023| 2.08k|}) | | ------------------ | | | Branch (1025:26): [True: 157, False: 1.92k] | | ------------------ ------------------ 1162| 157| thread_memory_magazine2_unload (tmem, ix); 1163| 2.08k| } 1164| 72.3k| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 72.3k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 72.3k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 72.3k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 72.3k| int _g_boolean_var_; \ | | | | 1018| 72.3k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 72.3k] | | | | ------------------ | | | | 1019| 72.3k| _g_boolean_var_ = 1; \ | | | | 1020| 72.3k| else \ | | | | 1021| 72.3k| _g_boolean_var_ = 0; \ | | | | 1022| 72.3k| _g_boolean_var_; \ | | | | 1023| 72.3k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 72.3k] | | ------------------ ------------------ 1165| 0| memset (mem_block, 0, chunk_size); 1166| 72.3k| thread_memory_magazine2_free (tmem, ix, mem_block); 1167| 72.3k| } 1168| 0| else if (acat == 2) /* allocate through slab allocator */ ------------------ | Branch (1168:12): [True: 0, False: 0] ------------------ 1169| 0| { 1170| 0| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 0|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 0] | | ------------------ ------------------ 1171| 0| memset (mem_block, 0, chunk_size); 1172| 0| g_mutex_lock (&allocator->slab_mutex); 1173| 0| slab_allocator_free_chunk (chunk_size, mem_block); 1174| 0| g_mutex_unlock (&allocator->slab_mutex); 1175| 0| } 1176| 0| else /* delegate to system malloc */ 1177| 0| { 1178| 0| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 0|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 0] | | ------------------ ------------------ 1179| 0| memset (mem_block, 0, mem_size); 1180| 0| g_free (mem_block); 1181| 0| } 1182| 72.3k| TRACE (GLIB_SLICE_FREE((void*)mem_block, mem_size)); 1183| 72.3k|} g_slice_free_chain_with_offset: 1209| 7.71k|{ 1210| 7.71k| gpointer slice = mem_chain; 1211| | /* while the thread magazines and the magazine cache are implemented so that 1212| | * they can easily be extended to allow for free lists containing more free 1213| | * lists for the first level nodes, which would allow O(1) freeing in this 1214| | * function, the benefit of such an extension is questionable, because: 1215| | * - the magazine size counts will become mere lower bounds which confuses 1216| | * the code adapting to lock contention; 1217| | * - freeing a single node to the thread magazines is very fast, so this 1218| | * O(list_length) operation is multiplied by a fairly small factor; 1219| | * - memory usage histograms on larger applications seem to indicate that 1220| | * the amount of released multi node lists is negligible in comparison 1221| | * to single node releases. 1222| | * - the major performance bottle neck, namely g_private_get() or 1223| | * g_mutex_lock()/g_mutex_unlock() has already been moved out of the 1224| | * inner loop for freeing chained slices. 1225| | */ 1226| 7.71k| gsize chunk_size = P2ALIGN (mem_size); ------------------ | | 207| 7.71k|#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf) ------------------ 1227| 7.71k| guint acat = allocator_categorize (chunk_size); 1228| 7.71k| if (G_LIKELY (acat == 1)) /* allocate through magazine layer */ ------------------ | | 1024| 7.71k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 7.71k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.71k| int _g_boolean_var_; \ | | | | 1018| 7.71k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 7.71k, False: 0] | | | | ------------------ | | | | 1019| 7.71k| _g_boolean_var_ = 1; \ | | | | 1020| 7.71k| else \ | | | | 1021| 7.71k| _g_boolean_var_ = 0; \ | | | | 1022| 7.71k| _g_boolean_var_; \ | | | | 1023| 7.71k|}) | | ------------------ | | | Branch (1024:24): [True: 7.71k, False: 0] | | ------------------ ------------------ 1229| 7.71k| { 1230| 7.71k| ThreadMemory *tmem = thread_memory_from_self(); 1231| 7.71k| guint ix = SLAB_INDEX (allocator, chunk_size); ------------------ | | 199| 7.71k|#define SLAB_INDEX(al, asize) ((asize) / P2ALIGNMENT - 1) /* asize must be P2ALIGNMENT aligned */ | | ------------------ | | | | 190| 7.71k|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 1232| 15.4k| while (slice) ------------------ | Branch (1232:14): [True: 7.70k, False: 7.71k] ------------------ 1233| 7.70k| { 1234| 7.70k| guint8 *current = slice; 1235| 7.70k| slice = *(gpointer*) (current + next_offset); 1236| 7.70k| if (G_UNLIKELY (allocator->config.debug_blocks) && ------------------ | | 1025| 15.4k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | 1018| 7.70k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 7.70k] | | | | ------------------ | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | 1020| 7.70k| else \ | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | 1023| 7.70k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 7.70k] | | ------------------ ------------------ 1237| 0| !smc_notify_free (current, mem_size)) ------------------ | Branch (1237:15): [True: 0, False: 0] ------------------ 1238| 0| abort(); 1239| 7.70k| if (G_UNLIKELY (thread_memory_magazine2_is_full (tmem, ix))) ------------------ | | 1025| 7.70k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | 1018| 7.70k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 7.70k] | | | | ------------------ | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | 1020| 7.70k| else \ | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | 1023| 7.70k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 7.70k] | | ------------------ ------------------ 1240| 0| { 1241| 0| thread_memory_swap_magazines (tmem, ix); 1242| 0| if (G_UNLIKELY (thread_memory_magazine2_is_full (tmem, ix))) ------------------ | | 1025| 0|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 0] | | ------------------ ------------------ 1243| 0| thread_memory_magazine2_unload (tmem, ix); 1244| 0| } 1245| 7.70k| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 7.70k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | 1018| 7.70k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 7.70k] | | | | ------------------ | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | 1020| 7.70k| else \ | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | 1023| 7.70k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 7.70k] | | ------------------ ------------------ 1246| 0| memset (current, 0, chunk_size); 1247| 7.70k| thread_memory_magazine2_free (tmem, ix, current); 1248| 7.70k| } 1249| 7.71k| } 1250| 0| else if (acat == 2) /* allocate through slab allocator */ ------------------ | Branch (1250:12): [True: 0, False: 0] ------------------ 1251| 0| { 1252| 0| g_mutex_lock (&allocator->slab_mutex); 1253| 0| while (slice) ------------------ | Branch (1253:14): [True: 0, False: 0] ------------------ 1254| 0| { 1255| 0| guint8 *current = slice; 1256| 0| slice = *(gpointer*) (current + next_offset); 1257| 0| if (G_UNLIKELY (allocator->config.debug_blocks) && ------------------ | | 1025| 0|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 0] | | ------------------ ------------------ 1258| 0| !smc_notify_free (current, mem_size)) ------------------ | Branch (1258:15): [True: 0, False: 0] ------------------ 1259| 0| abort(); 1260| 0| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 0|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 0] | | ------------------ ------------------ 1261| 0| memset (current, 0, chunk_size); 1262| 0| slab_allocator_free_chunk (chunk_size, current); 1263| 0| } 1264| 0| g_mutex_unlock (&allocator->slab_mutex); 1265| 0| } 1266| 0| else /* delegate to system malloc */ 1267| 0| while (slice) ------------------ | Branch (1267:12): [True: 0, False: 0] ------------------ 1268| 0| { 1269| 0| guint8 *current = slice; 1270| 0| slice = *(gpointer*) (current + next_offset); 1271| 0| if (G_UNLIKELY (allocator->config.debug_blocks) && ------------------ | | 1025| 0|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 0] | | ------------------ ------------------ 1272| 0| !smc_notify_free (current, mem_size)) ------------------ | Branch (1272:13): [True: 0, False: 0] ------------------ 1273| 0| abort(); 1274| 0| if (G_UNLIKELY (g_mem_gc_friendly)) ------------------ | | 1025| 0|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 0| int _g_boolean_var_; \ | | | | 1018| 0| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 0] | | | | ------------------ | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | 1020| 0| else \ | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | 1022| 0| _g_boolean_var_; \ | | | | 1023| 0|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 0] | | ------------------ ------------------ 1275| 0| memset (current, 0, mem_size); 1276| 0| g_free (current); 1277| 0| } 1278| 7.71k|} gslice.c:allocator_get_magazine_threshold: 615| 82.1k|{ 616| | /* the magazine size calculated here has a lower bound of MIN_MAGAZINE_SIZE, 617| | * which is required by the implementation. also, for moderately sized chunks 618| | * (say >= 64 bytes), magazine sizes shouldn't be much smaller then the number 619| | * of chunks available per page/2 to avoid excessive traffic in the magazine 620| | * cache for small to medium sized structures. 621| | * the upper bound of the magazine size is effectively provided by 622| | * MAX_MAGAZINE_SIZE. for larger chunks, this number is scaled down so that 623| | * the content of a single magazine doesn't exceed ca. 16KB. 624| | */ 625| 82.1k| gsize chunk_size = SLAB_CHUNK_SIZE (allocator, ix); ------------------ | | 200| 82.1k|#define SLAB_CHUNK_SIZE(al, ix) (((ix) + 1) * P2ALIGNMENT) | | ------------------ | | | | 190| 82.1k|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 626| 82.1k| guint threshold = MAX (MIN_MAGAZINE_SIZE, allocator->max_page_size / MAX (5 * chunk_size, 5 * 32)); ------------------ | | 822| 164k|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 0, False: 82.1k] | | | Branch (822:29): [True: 22.4k, False: 59.7k] | | | Branch (822:42): [True: 22.4k, False: 59.7k] | | ------------------ ------------------ 627| 82.1k| guint contention_counter = allocator->contention_counters[ix]; 628| 82.1k| if (G_UNLIKELY (contention_counter)) /* single CPU bias */ ------------------ | | 1025| 82.1k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 82.1k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 82.1k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 82.1k| int _g_boolean_var_; \ | | | | 1018| 82.1k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 82.1k] | | | | ------------------ | | | | 1019| 82.1k| _g_boolean_var_ = 1; \ | | | | 1020| 82.1k| else \ | | | | 1021| 82.1k| _g_boolean_var_ = 0; \ | | | | 1022| 82.1k| _g_boolean_var_; \ | | | | 1023| 82.1k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 82.1k] | | ------------------ ------------------ 629| 0| { 630| | /* adapt contention counter thresholds to chunk sizes */ 631| 0| contention_counter = contention_counter * 64 / chunk_size; 632| 0| threshold = MAX (threshold, contention_counter); ------------------ | | 822| 0|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 0, False: 0] | | ------------------ ------------------ 633| 0| } 634| 82.1k| return threshold; 635| 82.1k|} gslice.c:thread_memory_from_self: 551| 160k|{ 552| 160k| ThreadMemory *tmem = g_private_get (&private_thread_memory); 553| 160k| if (G_UNLIKELY (!tmem)) ------------------ | | 1025| 160k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 160k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 160k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 160k| int _g_boolean_var_; \ | | | | 1018| 160k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 2, False: 160k] | | | | ------------------ | | | | 1019| 160k| _g_boolean_var_ = 1; \ | | | | 1020| 160k| else \ | | | | 1021| 160k| _g_boolean_var_ = 0; \ | | | | 1022| 160k| _g_boolean_var_; \ | | | | 1023| 160k|}) | | ------------------ | | | Branch (1025:26): [True: 2, False: 160k] | | ------------------ ------------------ 554| 2| { 555| 2| static GMutex init_mutex; 556| 2| guint n_magazines; 557| | 558| 2| g_mutex_lock (&init_mutex); 559| 2| if G_UNLIKELY (sys_page_size == 0) ------------------ | | 1025| 2|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2| int _g_boolean_var_; \ | | | | 1018| 2| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 2, False: 0] | | | | ------------------ | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | 1020| 2| else \ | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | 1022| 2| _g_boolean_var_; \ | | | | 1023| 2|}) | | ------------------ | | | Branch (1025:27): [True: 2, False: 0] | | ------------------ ------------------ 560| 2| g_slice_init_nomessage (); 561| 2| g_mutex_unlock (&init_mutex); 562| | 563| 2| n_magazines = MAX_SLAB_INDEX (allocator); ------------------ | | 198| 2|#define MAX_SLAB_INDEX(al) (SLAB_INDEX (al, MAX_SLAB_CHUNK_SIZE (al)) + 1) | | ------------------ | | | | 199| 2|#define SLAB_INDEX(al, asize) ((asize) / P2ALIGNMENT - 1) /* asize must be P2ALIGNMENT aligned */ | | | | ------------------ | | | | | | 190| 2|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | | | ------------------ | | ------------------ ------------------ 564| 2| tmem = g_private_set_alloc0 (&private_thread_memory, sizeof (ThreadMemory) + sizeof (Magazine) * 2 * n_magazines); 565| 2| tmem->magazine1 = (Magazine*) (tmem + 1); 566| 2| tmem->magazine2 = &tmem->magazine1[n_magazines]; 567| 2| } 568| 160k| return tmem; 569| 160k|} gslice.c:magazine_cache_push_magazine: 734| 157|{ 735| 157| ChunkLink *current = magazine_chain_prepare_fields (magazine_chunks); 736| 157| ChunkLink *next, *prev; 737| 157| g_mutex_lock (&allocator->magazine_mutex); 738| | /* add magazine at head */ 739| 157| next = allocator->magazines[ix]; 740| 157| if (next) ------------------ | Branch (740:7): [True: 94, False: 63] ------------------ 741| 94| prev = magazine_chain_prev (next); ------------------ | | 672| 94|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 742| 63| else 743| 63| next = prev = current; 744| 157| magazine_chain_next (prev) = current; ------------------ | | 675| 157|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 745| 157| magazine_chain_prev (next) = current; ------------------ | | 672| 157|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 746| 157| magazine_chain_prev (current) = prev; ------------------ | | 672| 157|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 747| 157| magazine_chain_next (current) = next; ------------------ | | 675| 157|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 748| 157| magazine_chain_count (current) = (gpointer) count; ------------------ | | 676| 157|#define magazine_chain_count(mc) ((mc)->next->next->next->data) ------------------ 749| | /* stamp magazine */ 750| 157| magazine_cache_update_stamp(); 751| 157| magazine_chain_stamp (current) = GUINT_TO_POINTER (allocator->last_stamp); ------------------ | | 673| 157|#define magazine_chain_stamp(mc) ((mc)->next->data) ------------------ magazine_chain_stamp (current) = GUINT_TO_POINTER (allocator->last_stamp); ------------------ | | 102| 157|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 752| 157| allocator->magazines[ix] = current; 753| | /* free old magazines beyond a certain threshold */ 754| 157| magazine_cache_trim (allocator, ix, allocator->last_stamp); 755| | /* g_mutex_unlock (allocator->mutex); was done by magazine_cache_trim() */ 756| 157|} gslice.c:magazine_chain_prepare_fields: 653| 157|{ 654| 157| ChunkLink *chunk1; 655| 157| ChunkLink *chunk2; 656| 157| ChunkLink *chunk3; 657| 157| ChunkLink *chunk4; 658| | /* checked upon initialization: mem_assert (MIN_MAGAZINE_SIZE >= 4); */ 659| | /* ensure a magazine with at least 4 unused data pointers */ 660| 157| chunk1 = magazine_chain_pop_head (&magazine_chunks); 661| 157| chunk2 = magazine_chain_pop_head (&magazine_chunks); 662| 157| chunk3 = magazine_chain_pop_head (&magazine_chunks); 663| 157| chunk4 = magazine_chain_pop_head (&magazine_chunks); 664| 157| chunk4->next = magazine_chunks; 665| 157| chunk3->next = chunk4; 666| 157| chunk2->next = chunk3; 667| 157| chunk1->next = chunk2; 668| 157| return chunk1; 669| 157|} gslice.c:magazine_cache_update_stamp: 640| 159|{ 641| 159| if (allocator->stamp_counter >= MAX_STAMP_COUNTER) ------------------ | | 196| 159|#define MAX_STAMP_COUNTER (7) /* distributes the load of gettimeofday() */ ------------------ | Branch (641:7): [True: 21, False: 138] ------------------ 642| 21| { 643| 21| gint64 now_us = g_get_real_time (); 644| 21| allocator->last_stamp = now_us / 1000; /* milli seconds */ 645| 21| allocator->stamp_counter = 0; 646| 21| } 647| 138| else 648| 138| allocator->stamp_counter++; 649| 159|} gslice.c:magazine_cache_trim: 682| 157|{ 683| | /* g_mutex_lock (allocator->mutex); done by caller */ 684| | /* trim magazine cache from tail */ 685| 157| ChunkLink *current = magazine_chain_prev (allocator->magazines[ix]); ------------------ | | 672| 157|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 686| 157| ChunkLink *trash = NULL; 687| 157| while (!G_APPROX_VALUE(stamp, magazine_chain_uint_stamp (current), ------------------ | | 834| 157| (((a) > (b) ? (a) - (b) : (b) - (a)) < (epsilon)) | | ------------------ | | | Branch (834:5): [True: 67, False: 90] | | ------------------ ------------------ | Branch (687:10): [True: 0, False: 157] ------------------ 688| 157| allocator->config.working_set_msecs)) 689| 0| { 690| | /* unlink */ 691| 0| ChunkLink *prev = magazine_chain_prev (current); ------------------ | | 672| 0|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 692| 0| ChunkLink *next = magazine_chain_next (current); ------------------ | | 675| 0|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 693| 0| magazine_chain_next (prev) = next; ------------------ | | 675| 0|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 694| 0| magazine_chain_prev (next) = prev; ------------------ | | 672| 0|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 695| | /* clear special fields, put on trash stack */ 696| 0| magazine_chain_next (current) = NULL; ------------------ | | 675| 0|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 697| 0| magazine_chain_count (current) = NULL; ------------------ | | 676| 0|#define magazine_chain_count(mc) ((mc)->next->next->next->data) ------------------ 698| 0| magazine_chain_stamp (current) = NULL; ------------------ | | 673| 0|#define magazine_chain_stamp(mc) ((mc)->next->data) ------------------ 699| 0| magazine_chain_prev (current) = trash; ------------------ | | 672| 0|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 700| 0| trash = current; 701| | /* fixup list head if required */ 702| 0| if (current == allocator->magazines[ix]) ------------------ | Branch (702:11): [True: 0, False: 0] ------------------ 703| 0| { 704| 0| allocator->magazines[ix] = NULL; 705| 0| break; 706| 0| } 707| 0| current = prev; 708| 0| } 709| 157| g_mutex_unlock (&allocator->magazine_mutex); 710| | /* free trash */ 711| 157| if (trash) ------------------ | Branch (711:7): [True: 0, False: 157] ------------------ 712| 0| { 713| 0| const gsize chunk_size = SLAB_CHUNK_SIZE (allocator, ix); ------------------ | | 200| 0|#define SLAB_CHUNK_SIZE(al, ix) (((ix) + 1) * P2ALIGNMENT) | | ------------------ | | | | 190| 0|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 714| 0| g_mutex_lock (&allocator->slab_mutex); 715| 0| while (trash) ------------------ | Branch (715:14): [True: 0, False: 0] ------------------ 716| 0| { 717| 0| current = trash; 718| 0| trash = magazine_chain_prev (current); ------------------ | | 672| 0|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 719| 0| magazine_chain_prev (current) = NULL; /* clear special field */ ------------------ | | 672| 0|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 720| 0| while (current) ------------------ | Branch (720:18): [True: 0, False: 0] ------------------ 721| 0| { 722| 0| ChunkLink *chunk = magazine_chain_pop_head (¤t); 723| 0| slab_allocator_free_chunk (chunk_size, chunk); 724| 0| } 725| 0| } 726| 0| g_mutex_unlock (&allocator->slab_mutex); 727| 0| } 728| 157|} gslice.c:magazine_chain_pop_head: 573| 80.7k|{ 574| | /* magazine chains are linked via ChunkLink->next. 575| | * each ChunkLink->data of the toplevel chain may point to a subchain, 576| | * linked via ChunkLink->next. ChunkLink->data of the subchains just 577| | * contains uninitialized junk. 578| | */ 579| 80.7k| ChunkLink *chunk = (*magazine_chunks)->data; 580| 80.7k| if (G_UNLIKELY (chunk)) ------------------ | | 1025| 80.7k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 80.7k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 80.7k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 80.7k| int _g_boolean_var_; \ | | | | 1018| 80.7k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 80.7k] | | | | ------------------ | | | | 1019| 80.7k| _g_boolean_var_ = 1; \ | | | | 1020| 80.7k| else \ | | | | 1021| 80.7k| _g_boolean_var_ = 0; \ | | | | 1022| 80.7k| _g_boolean_var_; \ | | | | 1023| 80.7k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 80.7k] | | ------------------ ------------------ 581| 0| { 582| | /* allocating from freed list */ 583| 0| (*magazine_chunks)->data = chunk->next; 584| 0| } 585| 80.7k| else 586| 80.7k| { 587| 80.7k| chunk = *magazine_chunks; 588| 80.7k| *magazine_chunks = chunk->next; 589| 80.7k| } 590| 80.7k| return chunk; 591| 80.7k|} gslice.c:g_slice_init_nomessage: 443| 2|{ 444| | /* we may not use g_error() or friends here */ 445| 2| mem_assert (sys_page_size == 0); ------------------ | | 214| 2|#define mem_assert(cond) do { if (G_LIKELY (cond)) ; else mem_error ("assertion failed: %s", #cond); } while (0) | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | | Branch (214:114): [Folded, False: 2] | | ------------------ ------------------ 446| 2| mem_assert (MIN_MAGAZINE_SIZE >= 4); ------------------ | | 214| 2|#define mem_assert(cond) do { if (G_LIKELY (cond)) ; else mem_error ("assertion failed: %s", #cond); } while (0) | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, Folded] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | | Branch (214:114): [Folded, False: 2] | | ------------------ ------------------ 447| | 448| |#ifdef G_OS_WIN32 449| | { 450| | SYSTEM_INFO system_info; 451| | GetSystemInfo (&system_info); 452| | sys_page_size = system_info.dwPageSize; 453| | } 454| |#else 455| 2| sys_page_size = sysconf (_SC_PAGESIZE); /* = sysconf (_SC_PAGE_SIZE); = getpagesize(); */ 456| 2|#endif 457| 2| mem_assert (sys_page_size >= 2 * LARGEALIGNMENT); ------------------ | | 214| 2|#define mem_assert(cond) do { if (G_LIKELY (cond)) ; else mem_error ("assertion failed: %s", #cond); } while (0) | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | | Branch (214:114): [Folded, False: 2] | | ------------------ ------------------ 458| 2| mem_assert ((sys_page_size & (sys_page_size - 1)) == 0); ------------------ | | 214| 2|#define mem_assert(cond) do { if (G_LIKELY (cond)) ; else mem_error ("assertion failed: %s", #cond); } while (0) | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | | Branch (214:114): [Folded, False: 2] | | ------------------ ------------------ 459| 2| slice_config_init (&allocator->config); 460| 2| allocator->min_page_size = sys_page_size; 461| 2|#if HAVE_POSIX_MEMALIGN || HAVE_MEMALIGN 462| | /* allow allocation of pages up to 8KB (with 8KB alignment). 463| | * this is useful because many medium to large sized structures 464| | * fit less than 8 times (see [4]) into 4KB pages. 465| | * we allow very small page sizes here, to reduce wastage in 466| | * threads if only small allocations are required (this does 467| | * bear the risk of increasing allocation times and fragmentation 468| | * though). 469| | */ 470| 2| allocator->min_page_size = MAX (allocator->min_page_size, 4096); ------------------ | | 822| 2|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 0, False: 2] | | ------------------ ------------------ 471| 2| allocator->max_page_size = MAX (allocator->min_page_size, 8192); ------------------ | | 822| 2|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 0, False: 2] | | ------------------ ------------------ 472| 2| allocator->min_page_size = MIN (allocator->min_page_size, 128); ------------------ | | 825| 2|#define MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (825:21): [True: 0, False: 2] | | ------------------ ------------------ 473| |#else 474| | /* we can only align to system page size */ 475| | allocator->max_page_size = sys_page_size; 476| |#endif 477| 2| if (allocator->config.always_malloc) ------------------ | Branch (477:7): [True: 0, False: 2] ------------------ 478| 0| { 479| 0| allocator->contention_counters = NULL; 480| 0| allocator->magazines = NULL; 481| 0| allocator->slab_stack = NULL; 482| 0| } 483| 2| else 484| 2| { 485| 2| allocator->contention_counters = g_new0 (guint, MAX_SLAB_INDEX (allocator)); ------------------ | | 307| 2|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2| gsize __n = (gsize) (n_structs); \ | | | | 237| 2| gsize __s = sizeof (struct_type); \ | | | | 238| 2| gpointer __p; \ | | | | 239| 2| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2] | | | | ------------------ | | | | 240| 2| __p = g_##func (__n); \ | | | | 241| 2| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 2] | | | | ------------------ | | | | 242| 2| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 2| __p = g_##func (__n * __s); \ | | | | 244| 2| else \ | | | | 245| 2| __p = g_##func##_n (__n, __s); \ | | | | 246| 2| __p; \ | | | | 247| 2| })) | | ------------------ ------------------ 486| 2| allocator->magazines = g_new0 (ChunkLink*, MAX_SLAB_INDEX (allocator)); ------------------ | | 307| 2|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2| gsize __n = (gsize) (n_structs); \ | | | | 237| 2| gsize __s = sizeof (struct_type); \ | | | | 238| 2| gpointer __p; \ | | | | 239| 2| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2] | | | | ------------------ | | | | 240| 2| __p = g_##func (__n); \ | | | | 241| 2| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 2] | | | | ------------------ | | | | 242| 2| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 2| __p = g_##func (__n * __s); \ | | | | 244| 2| else \ | | | | 245| 2| __p = g_##func##_n (__n, __s); \ | | | | 246| 2| __p; \ | | | | 247| 2| })) | | ------------------ ------------------ 487| 2| allocator->slab_stack = g_new0 (SlabInfo*, MAX_SLAB_INDEX (allocator)); ------------------ | | 307| 2|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2| gsize __n = (gsize) (n_structs); \ | | | | 237| 2| gsize __s = sizeof (struct_type); \ | | | | 238| 2| gpointer __p; \ | | | | 239| 2| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2] | | | | ------------------ | | | | 240| 2| __p = g_##func (__n); \ | | | | 241| 2| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 2] | | | | ------------------ | | | | 242| 2| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 2| __p = g_##func (__n * __s); \ | | | | 244| 2| else \ | | | | 245| 2| __p = g_##func##_n (__n, __s); \ | | | | 246| 2| __p; \ | | | | 247| 2| })) | | ------------------ ------------------ 488| 2| } 489| | 490| 2| allocator->mutex_counter = 0; 491| 2| allocator->stamp_counter = MAX_STAMP_COUNTER; /* force initial update */ ------------------ | | 196| 2|#define MAX_STAMP_COUNTER (7) /* distributes the load of gettimeofday() */ ------------------ 492| 2| allocator->last_stamp = 0; 493| 2| allocator->color_accu = 0; 494| 2| magazine_cache_update_stamp(); 495| | /* values cached for performance reasons */ 496| 2| allocator->max_slab_chunk_size_for_magazine_cache = MAX_SLAB_CHUNK_SIZE (allocator); ------------------ | | 197| 2|#define MAX_SLAB_CHUNK_SIZE(al) (((al)->max_page_size - SLAB_INFO_SIZE) / 8) /* we want at last 8 chunks per page, see [4] */ | | ------------------ | | | | 193| 2|#define SLAB_INFO_SIZE P2ALIGN (sizeof (SlabInfo) + NATIVE_MALLOC_PADDING) | | | | ------------------ | | | | | | 207| 2|#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf) | | | | ------------------ | | ------------------ ------------------ 497| 2| if (allocator->config.always_malloc || allocator->config.bypass_magazines) ------------------ | Branch (497:7): [True: 0, False: 2] | Branch (497:42): [True: 0, False: 2] ------------------ 498| 0| allocator->max_slab_chunk_size_for_magazine_cache = 0; /* non-optimized cases */ 499| 2|} gslice.c:slice_config_init: 362| 2|{ 363| 2| const gchar *val; 364| 2| gchar *val_allocated = NULL; 365| | 366| 2| *config = slice_config; 367| | 368| | /* Note that the empty string (`G_SLICE=""`) is treated differently from the 369| | * envvar being unset. In the latter case, we also check whether running under 370| | * valgrind. */ 371| 2|#ifndef G_OS_WIN32 372| 2| val = g_getenv ("G_SLICE"); 373| |#else 374| | /* The win32 implementation of g_getenv() has to do UTF-8 ↔ UTF-16 conversions 375| | * which use the slice allocator, leading to deadlock. Use a simple in-place 376| | * implementation here instead. 377| | * 378| | * Ignore references to other environment variables: only support values which 379| | * are a combination of always-malloc and debug-blocks. */ 380| | { 381| | 382| | wchar_t wvalue[128]; /* at least big enough for `always-malloc,debug-blocks` */ 383| | int len; 384| | 385| | len = GetEnvironmentVariableW (L"G_SLICE", wvalue, G_N_ELEMENTS (wvalue)); 386| | 387| | if (len == 0) 388| | { 389| | if (GetLastError () == ERROR_ENVVAR_NOT_FOUND) 390| | val = NULL; 391| | else 392| | val = ""; 393| | } 394| | else if (len >= G_N_ELEMENTS (wvalue)) 395| | { 396| | /* @wvalue isn’t big enough. Give up. */ 397| | g_warning ("Unsupported G_SLICE value"); 398| | val = NULL; 399| | } 400| | else 401| | { 402| | /* it’s safe to use g_utf16_to_utf8() here as it only allocates using 403| | * malloc() rather than GSlice */ 404| | val = val_allocated = g_utf16_to_utf8 (wvalue, -1, NULL, NULL, NULL); 405| | } 406| | 407| | } 408| |#endif /* G_OS_WIN32 */ 409| | 410| 2| if (val != NULL) ------------------ | Branch (410:7): [True: 0, False: 2] ------------------ 411| 0| { 412| 0| gint flags; 413| 0| const GDebugKey keys[] = { 414| 0| { "always-malloc", 1 << 0 }, 415| 0| { "debug-blocks", 1 << 1 }, 416| 0| }; 417| | 418| 0| flags = g_parse_debug_string (val, keys, G_N_ELEMENTS (keys)); ------------------ | | 840| 0|#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) ------------------ 419| 0| if (flags & (1 << 0)) ------------------ | Branch (419:11): [True: 0, False: 0] ------------------ 420| 0| config->always_malloc = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 421| 0| if (flags & (1 << 1)) ------------------ | Branch (421:11): [True: 0, False: 0] ------------------ 422| 0| config->debug_blocks = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 423| 0| } 424| 2| else 425| 2| { 426| | /* G_SLICE was not specified, so check if valgrind is running and 427| | * disable ourselves if it is. 428| | * 429| | * This way it's possible to force gslice to be enabled under 430| | * valgrind just by setting G_SLICE to the empty string. 431| | */ 432| 2|#ifdef ENABLE_VALGRIND 433| 2| if (RUNNING_ON_VALGRIND) ------------------ | | 6215| 2| (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ | | ------------------ | | | | 413| 2| __extension__ \ | | | | 414| 2| ({ volatile unsigned long int _zzq_args[6]; \ | | | | 415| 2| volatile unsigned long int _zzq_result; \ | | | | 416| 2| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | 417| 2| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | 418| 2| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | 419| 2| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | 420| 2| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | 421| 2| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | 422| 2| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | 423| 2| /* %RDX = client_request ( %RAX ) */ \ | | | | 424| 2| "xchgq %%rbx,%%rbx" \ | | | | 425| 2| : "=d" (_zzq_result) \ | | | | 426| 2| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | 427| 2| : "cc", "memory" \ | | | | 428| 2| ); \ | | | | 429| 2| _zzq_result; \ | | | | 430| 2| }) | | ------------------ | | | Branch (6215:5): [True: 0, False: 2] | | ------------------ | | 6216| 2| VG_USERREQ__RUNNING_ON_VALGRIND, \ | | 6217| 2| 0, 0, 0, 0, 0) \ ------------------ 434| 0| config->always_malloc = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 435| 2|#endif 436| 2| } 437| | 438| 2| g_free (val_allocated); 439| 2|} gslice.c:allocator_categorize: 503| 160k|{ 504| | /* speed up the likely path */ 505| 160k| if (G_LIKELY (aligned_chunk_size && aligned_chunk_size <= allocator->max_slab_chunk_size_for_magazine_cache)) ------------------ | | 1024| 160k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 160k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 160k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 160k| int _g_boolean_var_; \ | | | | 1018| 480k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 160k, False: 0] | | | | | Branch (1018:8): [True: 160k, False: 0] | | | | ------------------ | | | | 1019| 160k| _g_boolean_var_ = 1; \ | | | | 1020| 160k| else \ | | | | 1021| 160k| _g_boolean_var_ = 0; \ | | | | 1022| 160k| _g_boolean_var_; \ | | | | 1023| 160k|}) | | ------------------ | | | Branch (1024:24): [True: 160k, False: 0] | | ------------------ ------------------ 506| 160k| return 1; /* use magazine cache */ 507| | 508| 0| if (!allocator->config.always_malloc && ------------------ | Branch (508:7): [True: 0, False: 0] ------------------ 509| 0| aligned_chunk_size && ------------------ | Branch (509:7): [True: 0, False: 0] ------------------ 510| 0| aligned_chunk_size <= MAX_SLAB_CHUNK_SIZE (allocator)) ------------------ | | 197| 0|#define MAX_SLAB_CHUNK_SIZE(al) (((al)->max_page_size - SLAB_INFO_SIZE) / 8) /* we want at last 8 chunks per page, see [4] */ | | ------------------ | | | | 193| 0|#define SLAB_INFO_SIZE P2ALIGN (sizeof (SlabInfo) + NATIVE_MALLOC_PADDING) | | | | ------------------ | | | | | | 207| 0|#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf) | | | | ------------------ | | ------------------ ------------------ | Branch (510:7): [True: 0, False: 0] ------------------ 511| 0| { 512| 0| if (allocator->config.bypass_magazines) ------------------ | Branch (512:11): [True: 0, False: 0] ------------------ 513| 0| return 2; /* use slab allocator, see [2] */ 514| 0| return 1; /* use magazine cache */ 515| 0| } 516| 0| return 0; /* use malloc() */ 517| 0|} gslice.c:thread_memory_magazine1_is_empty: 870| 82.6k|{ 871| | return tmem->magazine1[ix].chunks == NULL; 872| 82.6k|} gslice.c:thread_memory_swap_magazines: 861| 4.65k|{ 862| 4.65k| Magazine xmag = tmem->magazine1[ix]; 863| 4.65k| tmem->magazine1[ix] = tmem->magazine2[ix]; 864| 4.65k| tmem->magazine2[ix] = xmag; 865| 4.65k|} gslice.c:thread_memory_magazine1_reload: 841| 168|{ 842| 168| Magazine *mag = &tmem->magazine1[ix]; 843| 168| mem_assert (mag->chunks == NULL); /* ensure that we may reset mag->count */ ------------------ | | 214| 168|#define mem_assert(cond) do { if (G_LIKELY (cond)) ; else mem_error ("assertion failed: %s", #cond); } while (0) | | ------------------ | | | | 1024| 168|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 168| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 168|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 168| int _g_boolean_var_; \ | | | | | | 1018| 168| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 168, False: 0] | | | | | | ------------------ | | | | | | 1019| 168| _g_boolean_var_ = 1; \ | | | | | | 1020| 168| else \ | | | | | | 1021| 168| _g_boolean_var_ = 0; \ | | | | | | 1022| 168| _g_boolean_var_; \ | | | | | | 1023| 168|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 168, False: 0] | | | | ------------------ | | ------------------ | | | Branch (214:114): [Folded, False: 168] | | ------------------ ------------------ 844| 168| mag->count = 0; 845| 168| mag->chunks = magazine_cache_pop_magazine (ix, &mag->count); 846| 168|} gslice.c:magazine_cache_pop_magazine: 761| 168|{ 762| 168| g_mutex_lock_a (&allocator->magazine_mutex, &allocator->contention_counters[ix]); 763| 168| if (!allocator->magazines[ix]) ------------------ | Branch (763:7): [True: 27, False: 141] ------------------ 764| 27| { 765| 27| guint magazine_threshold = allocator_get_magazine_threshold (allocator, ix); 766| 27| gsize i, chunk_size = SLAB_CHUNK_SIZE (allocator, ix); ------------------ | | 200| 27|#define SLAB_CHUNK_SIZE(al, ix) (((ix) + 1) * P2ALIGNMENT) | | ------------------ | | | | 190| 27|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 767| 27| ChunkLink *chunk, *head; 768| 27| g_mutex_unlock (&allocator->magazine_mutex); 769| 27| g_mutex_lock (&allocator->slab_mutex); 770| 27| head = slab_allocator_alloc_chunk (chunk_size); 771| 27| head->data = NULL; 772| 27| chunk = head; 773| 1.06k| for (i = 1; i < magazine_threshold; i++) ------------------ | Branch (773:19): [True: 1.03k, False: 27] ------------------ 774| 1.03k| { 775| 1.03k| chunk->next = slab_allocator_alloc_chunk (chunk_size); 776| 1.03k| chunk = chunk->next; 777| 1.03k| chunk->data = NULL; 778| 1.03k| } 779| 27| chunk->next = NULL; 780| 27| g_mutex_unlock (&allocator->slab_mutex); 781| 27| *countp = i; 782| 27| return head; 783| 27| } 784| 141| else 785| 141| { 786| 141| ChunkLink *current = allocator->magazines[ix]; 787| 141| ChunkLink *prev = magazine_chain_prev (current); ------------------ | | 672| 141|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 788| 141| ChunkLink *next = magazine_chain_next (current); ------------------ | | 675| 141|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 789| | /* unlink */ 790| 141| magazine_chain_next (prev) = next; ------------------ | | 675| 141|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 791| 141| magazine_chain_prev (next) = prev; ------------------ | | 672| 141|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 792| 141| allocator->magazines[ix] = next == current ? NULL : next; ------------------ | Branch (792:34): [True: 61, False: 80] ------------------ 793| 141| g_mutex_unlock (&allocator->magazine_mutex); 794| | /* clear special fields and hand out */ 795| 141| *countp = (gsize) magazine_chain_count (current); ------------------ | | 676| 141|#define magazine_chain_count(mc) ((mc)->next->next->next->data) ------------------ 796| 141| magazine_chain_prev (current) = NULL; ------------------ | | 672| 141|#define magazine_chain_prev(mc) ((mc)->data) ------------------ 797| 141| magazine_chain_next (current) = NULL; ------------------ | | 675| 141|#define magazine_chain_next(mc) ((mc)->next->next->data) ------------------ 798| 141| magazine_chain_count (current) = NULL; ------------------ | | 676| 141|#define magazine_chain_count(mc) ((mc)->next->next->next->data) ------------------ 799| 141| magazine_chain_stamp (current) = NULL; ------------------ | | 673| 141|#define magazine_chain_stamp(mc) ((mc)->next->data) ------------------ 800| 141| return current; 801| 141| } 802| 168|} gslice.c:g_mutex_lock_a: 522| 168|{ 523| 168| gboolean contention = FALSE; ------------------ | | 814| 168|#define FALSE (0) ------------------ 524| 168| if (!g_mutex_trylock (mutex)) ------------------ | Branch (524:7): [True: 0, False: 168] ------------------ 525| 0| { 526| 0| g_mutex_lock (mutex); 527| 0| contention = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 528| 0| } 529| 168| if (contention) ------------------ | Branch (529:7): [True: 0, False: 168] ------------------ 530| 0| { 531| 0| allocator->mutex_counter++; 532| 0| if (allocator->mutex_counter >= 1) /* quickly adapt to contention */ ------------------ | Branch (532:11): [True: 0, False: 0] ------------------ 533| 0| { 534| 0| allocator->mutex_counter = 0; 535| 0| *contention_counter = MIN (*contention_counter + 1, MAX_MAGAZINE_SIZE); ------------------ | | 825| 0|#define MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (825:21): [True: 0, False: 0] | | ------------------ ------------------ 536| 0| } 537| 0| } 538| 168| else /* !contention */ 539| 168| { 540| 168| allocator->mutex_counter--; 541| 168| if (allocator->mutex_counter < -11) /* moderately recover magazine sizes */ ------------------ | Branch (541:11): [True: 13, False: 155] ------------------ 542| 13| { 543| 13| allocator->mutex_counter = 0; 544| 13| *contention_counter = MAX (*contention_counter, 1) - 1; ------------------ | | 822| 13|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 0, False: 13] | | ------------------ ------------------ 545| 13| } 546| 168| } 547| 168|} gslice.c:thread_memory_magazine1_alloc: 884| 80.0k|{ 885| 80.0k| Magazine *mag = &tmem->magazine1[ix]; 886| 80.0k| ChunkLink *chunk = magazine_chain_pop_head (&mag->chunks); 887| 80.0k| if (G_LIKELY (mag->count > 0)) ------------------ | | 1024| 80.0k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 80.0k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 80.0k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 80.0k| int _g_boolean_var_; \ | | | | 1018| 80.0k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 80.0k, False: 0] | | | | ------------------ | | | | 1019| 80.0k| _g_boolean_var_ = 1; \ | | | | 1020| 80.0k| else \ | | | | 1021| 80.0k| _g_boolean_var_ = 0; \ | | | | 1022| 80.0k| _g_boolean_var_; \ | | | | 1023| 80.0k|}) | | ------------------ | | | Branch (1024:24): [True: 80.0k, False: 0] | | ------------------ ------------------ 888| 80.0k| mag->count--; 889| 80.0k| return chunk; 890| 80.0k|} gslice.c:thread_memory_magazine2_is_full: 877| 82.1k|{ 878| 82.1k| return tmem->magazine2[ix].count >= allocator_get_magazine_threshold (allocator, ix); 879| 82.1k|} gslice.c:thread_memory_magazine2_unload: 851| 157|{ 852| 157| Magazine *mag = &tmem->magazine2[ix]; 853| 157| magazine_cache_push_magazine (ix, mag->chunks, mag->count); 854| | mag->chunks = NULL; 855| 157| mag->count = 0; 856| 157|} gslice.c:thread_memory_magazine2_free: 896| 80.0k|{ 897| 80.0k| Magazine *mag = &tmem->magazine2[ix]; 898| 80.0k| ChunkLink *chunk = mem; 899| | chunk->data = NULL; 900| 80.0k| chunk->next = mag->chunks; 901| 80.0k| mag->chunks = chunk; 902| 80.0k| mag->count++; 903| 80.0k|} gslice.c:slab_allocator_alloc_chunk: 1369| 1.06k|{ 1370| 1.06k| ChunkLink *chunk; 1371| 1.06k| guint ix = SLAB_INDEX (allocator, chunk_size); ------------------ | | 199| 1.06k|#define SLAB_INDEX(al, asize) ((asize) / P2ALIGNMENT - 1) /* asize must be P2ALIGNMENT aligned */ | | ------------------ | | | | 190| 1.06k|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 1372| | /* ensure non-empty slab */ 1373| 1.06k| if (!allocator->slab_stack[ix] || !allocator->slab_stack[ix]->chunks) ------------------ | Branch (1373:7): [True: 9, False: 1.05k] | Branch (1373:37): [True: 83, False: 972] ------------------ 1374| 92| allocator_add_slab (allocator, ix, chunk_size); 1375| | /* allocate chunk */ 1376| 1.06k| chunk = allocator->slab_stack[ix]->chunks; 1377| 1.06k| allocator->slab_stack[ix]->chunks = chunk->next; 1378| 1.06k| allocator->slab_stack[ix]->n_allocated++; 1379| | /* rotate empty slabs */ 1380| 1.06k| if (!allocator->slab_stack[ix]->chunks) ------------------ | Branch (1380:7): [True: 83, False: 981] ------------------ 1381| 83| allocator->slab_stack[ix] = allocator->slab_stack[ix]->next; 1382| 1.06k| return chunk; 1383| 1.06k|} gslice.c:allocator_add_slab: 1316| 92|{ 1317| 92| ChunkLink *chunk; 1318| 92| SlabInfo *sinfo; 1319| 92| gsize addr, padding, n_chunks, color = 0; 1320| 92| gsize page_size; 1321| 92| int errsv; 1322| 92| gpointer aligned_memory; 1323| 92| guint8 *mem; 1324| 92| guint i; 1325| | 1326| 92| page_size = allocator_aligned_page_size (allocator, SLAB_BPAGE_SIZE (allocator, chunk_size)); ------------------ | | 201| 92|#define SLAB_BPAGE_SIZE(al,csz) (8 * (csz) + SLAB_INFO_SIZE) | | ------------------ | | | | 193| 92|#define SLAB_INFO_SIZE P2ALIGN (sizeof (SlabInfo) + NATIVE_MALLOC_PADDING) | | | | ------------------ | | | | | | 207| 92|#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf) | | | | ------------------ | | ------------------ ------------------ 1327| | /* allocate 1 page for the chunks and the slab */ 1328| 92| aligned_memory = allocator_memalign (page_size, page_size - NATIVE_MALLOC_PADDING); ------------------ | | 192| 92|#define NATIVE_MALLOC_PADDING P2ALIGNMENT /* per-page padding left for native malloc(3) see [1] */ | | ------------------ | | | | 190| 92|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 1329| 92| errsv = errno; 1330| 92| mem = aligned_memory; 1331| | 1332| 92| if (!mem) ------------------ | Branch (1332:7): [True: 0, False: 92] ------------------ 1333| 0| { 1334| 0| const gchar *syserr = strerror (errsv); 1335| 0| mem_error ("failed to allocate %u bytes (alignment: %u): %s\n", 1336| 0| (guint) (page_size - NATIVE_MALLOC_PADDING), (guint) page_size, syserr); ------------------ | | 192| 0|#define NATIVE_MALLOC_PADDING P2ALIGNMENT /* per-page padding left for native malloc(3) see [1] */ | | ------------------ | | | | 190| 0|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ | | ------------------ ------------------ 1337| 0| } 1338| | /* mask page address */ 1339| 92| addr = ((gsize) mem / page_size) * page_size; 1340| | /* assert alignment */ 1341| 92| mem_assert (aligned_memory == (gpointer) addr); ------------------ | | 214| 92|#define mem_assert(cond) do { if (G_LIKELY (cond)) ; else mem_error ("assertion failed: %s", #cond); } while (0) | | ------------------ | | | | 1024| 92|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 92| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 92|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 92| int _g_boolean_var_; \ | | | | | | 1018| 92| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 92, False: 0] | | | | | | ------------------ | | | | | | 1019| 92| _g_boolean_var_ = 1; \ | | | | | | 1020| 92| else \ | | | | | | 1021| 92| _g_boolean_var_ = 0; \ | | | | | | 1022| 92| _g_boolean_var_; \ | | | | | | 1023| 92|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 92, False: 0] | | | | ------------------ | | ------------------ | | | Branch (214:114): [Folded, False: 92] | | ------------------ ------------------ 1342| | /* basic slab info setup */ 1343| 92| sinfo = (SlabInfo*) (mem + page_size - SLAB_INFO_SIZE); ------------------ | | 193| 92|#define SLAB_INFO_SIZE P2ALIGN (sizeof (SlabInfo) + NATIVE_MALLOC_PADDING) | | ------------------ | | | | 207| 92|#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf) | | ------------------ ------------------ 1344| 92| sinfo->n_allocated = 0; 1345| 92| sinfo->chunks = NULL; 1346| | /* figure cache colorization */ 1347| 92| n_chunks = ((guint8*) sinfo - mem) / chunk_size; 1348| 92| padding = ((guint8*) sinfo - mem) - n_chunks * chunk_size; 1349| 92| if (padding) ------------------ | Branch (1349:7): [True: 84, False: 8] ------------------ 1350| 84| { 1351| 84| color = (allocator->color_accu * P2ALIGNMENT) % padding; ------------------ | | 190| 84|#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */ ------------------ 1352| 84| allocator->color_accu += allocator->config.color_increment; 1353| 84| } 1354| | /* add chunks to free list */ 1355| 92| chunk = (ChunkLink*) (mem + color); 1356| 92| sinfo->chunks = chunk; 1357| 1.09k| for (i = 0; i < n_chunks - 1; i++) ------------------ | Branch (1357:15): [True: 1.00k, False: 92] ------------------ 1358| 1.00k| { 1359| 1.00k| chunk->next = (ChunkLink*) ((guint8*) chunk + chunk_size); 1360| 1.00k| chunk = chunk->next; 1361| 1.00k| } 1362| 92| chunk->next = NULL; /* last chunk */ 1363| | /* add slab to slab ring */ 1364| 92| allocator_slab_stack_push (allocator, ix, sinfo); 1365| 92|} gslice.c:allocator_aligned_page_size: 1306| 92|{ 1307| 92| gsize val = 1 << g_bit_storage (n_bytes - 1); ------------------ | | 370| 92|#define g_bit_storage(number) g_bit_storage_impl(number) ------------------ 1308| 92| val = MAX (val, allocator->min_page_size); ------------------ | | 822| 92|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 92, False: 0] | | ------------------ ------------------ 1309| 92| return val; 1310| 92|} gslice.c:allocator_memalign: 1452| 92|{ 1453| 92| gpointer aligned_memory = NULL; 1454| 92| gint err = ENOMEM; 1455| 92|#if HAVE_POSIX_MEMALIGN 1456| 92| err = posix_memalign (&aligned_memory, alignment, memsize); 1457| |#elif HAVE_MEMALIGN 1458| | errno = 0; 1459| | aligned_memory = memalign (alignment, memsize); 1460| | err = errno; 1461| |#elif HAVE_VALLOC 1462| | errno = 0; 1463| | aligned_memory = valloc (memsize); 1464| | err = errno; 1465| |#else 1466| | /* simplistic non-freeing page allocator */ 1467| | mem_assert (alignment == sys_page_size); 1468| | mem_assert (memsize <= sys_page_size); 1469| | if (!compat_valloc_trash) 1470| | { 1471| | const guint n_pages = 16; 1472| | guint8 *mem = malloc (n_pages * sys_page_size); 1473| | err = errno; 1474| | if (mem) 1475| | { 1476| | gint i = n_pages; 1477| | guint8 *amem = (guint8*) ALIGN ((gsize) mem, sys_page_size); 1478| | if (amem != mem) 1479| | i--; /* mem wasn't page aligned */ 1480| | G_GNUC_BEGIN_IGNORE_DEPRECATIONS 1481| | while (--i >= 0) 1482| | g_trash_stack_push (&compat_valloc_trash, amem + i * sys_page_size); 1483| | G_GNUC_END_IGNORE_DEPRECATIONS 1484| | } 1485| | } 1486| | G_GNUC_BEGIN_IGNORE_DEPRECATIONS 1487| | aligned_memory = g_trash_stack_pop (&compat_valloc_trash); 1488| | G_GNUC_END_IGNORE_DEPRECATIONS 1489| |#endif 1490| 92| if (!aligned_memory) ------------------ | Branch (1490:7): [True: 0, False: 92] ------------------ 1491| 92| errno = err; 1492| 92| return aligned_memory; 1493| 92|} gslice.c:allocator_slab_stack_push: 1285| 92|{ 1286| | /* insert slab at slab ring head */ 1287| 92| if (!allocator->slab_stack[ix]) ------------------ | Branch (1287:7): [True: 9, False: 83] ------------------ 1288| 9| { 1289| 9| sinfo->next = sinfo; 1290| 9| sinfo->prev = sinfo; 1291| 9| } 1292| 83| else 1293| 83| { 1294| 83| SlabInfo *next = allocator->slab_stack[ix], *prev = next->prev; 1295| 83| next->prev = sinfo; 1296| 83| prev->next = sinfo; 1297| 83| sinfo->next = next; 1298| 83| sinfo->prev = prev; 1299| 83| } 1300| 92| allocator->slab_stack[ix] = sinfo; 1301| 92|} g_slist_free: 148| 7.71k|{ 149| | g_slice_free_chain (GSList, list, next); ------------------ | | 84| 7.71k|#define g_slice_free_chain(type, mem_chain, next) \ | | ------------------ | | | | 874| 7.71k|#define G_STMT_START do | | ------------------ | | 85| 7.71k|G_STMT_START { \ | | 86| 7.71k| if (1) g_slice_free_chain_with_offset (sizeof (type), \ | | ------------------ | | | Branch (86:7): [True: 7.71k, Folded] | | ------------------ | | 87| 7.71k| (mem_chain), G_STRUCT_OFFSET (type, next)); \ | | ------------------ | | | | 853| 7.71k| ((glong) offsetof (struct_type, member)) | | ------------------ | | 88| 7.71k| else (void) ((type*) 0 == (mem_chain)); \ | | 89| 7.71k|} G_STMT_END | | ------------------ | | | | 882| 7.71k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.71k] | | | | ------------------ | | ------------------ ------------------ 150| 7.71k|} g_slist_free_1: 168| 15|{ 169| 15| _g_slist_free1 (list); ------------------ | | 111| 15|#define _g_slist_free1(slist) g_slice_free (GSList, slist) | | ------------------ | | | | 79| 15|#define g_slice_free(type, mem) \ | | | | ------------------ | | | | | | 874| 15|#define G_STMT_START do | | | | ------------------ | | | | 80| 15|G_STMT_START { \ | | | | 81| 15| if (1) g_slice_free1 (sizeof (type), (mem)); \ | | | | ------------------ | | | | | Branch (81:7): [True: 15, Folded] | | | | ------------------ | | | | 82| 15| else (void) ((type*) 0 == (mem)); \ | | | | 83| 15|} G_STMT_END | | | | ------------------ | | | | | | 882| 15|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 15] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 170| 15|} g_slist_free_full: 197| 3.85k|{ 198| | g_slist_foreach (list, (GFunc) free_func, NULL); 199| 3.85k| g_slist_free (list); 200| 3.85k|} g_slist_append: 235| 3.85k|{ 236| 3.85k| GSList *new_list; 237| 3.85k| GSList *last; 238| | 239| 3.85k| new_list = _g_slist_alloc (); ------------------ | | 110| 3.85k|#define _g_slist_alloc() g_slice_new (GSList) | | ------------------ | | | | 46| 3.85k|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) | | ------------------ ------------------ 240| 3.85k| new_list->data = data; 241| 3.85k| new_list->next = NULL; 242| | 243| 3.85k| if (list) ------------------ | Branch (243:7): [True: 0, False: 3.85k] ------------------ 244| 0| { 245| 0| last = g_slist_last (list); 246| | /* g_assert (last != NULL); */ 247| 0| last->next = new_list; 248| | 249| 0| return list; 250| 0| } 251| 3.85k| else 252| 3.85k| return new_list; 253| 3.85k|} g_slist_prepend: 277| 3.87k|{ 278| 3.87k| GSList *new_list; 279| | 280| 3.87k| new_list = _g_slist_alloc (); ------------------ | | 110| 3.87k|#define _g_slist_alloc() g_slice_new (GSList) | | ------------------ | | | | 46| 3.87k|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) | | ------------------ ------------------ 281| 3.87k| new_list->data = data; 282| 3.87k| new_list->next = list; 283| | 284| 3.87k| return new_list; 285| 3.87k|} g_slist_remove: 453| 15|{ 454| 15| return _g_slist_remove_data (list, data, FALSE); ------------------ | | 814| 15|#define FALSE (0) ------------------ 455| 15|} g_slist_copy: 566| 4|{ 567| 4| return g_slist_copy_deep (list, NULL, NULL); 568| 4|} g_slist_copy_deep: 603| 4|{ 604| 4| GSList *new_list = NULL; 605| | 606| 4| if (list) ------------------ | Branch (606:7): [True: 1, False: 3] ------------------ 607| 1| { 608| 1| GSList *last; 609| | 610| 1| new_list = _g_slist_alloc (); ------------------ | | 110| 1|#define _g_slist_alloc() g_slice_new (GSList) | | ------------------ | | | | 46| 1|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) | | ------------------ ------------------ 611| 1| if (func) ------------------ | Branch (611:11): [True: 0, False: 1] ------------------ 612| 0| new_list->data = func (list->data, user_data); 613| 1| else 614| 1| new_list->data = list->data; 615| 1| last = new_list; 616| 1| list = list->next; 617| 1| while (list) ------------------ | Branch (617:14): [True: 0, False: 1] ------------------ 618| 0| { 619| 0| last->next = _g_slist_alloc (); ------------------ | | 110| 0|#define _g_slist_alloc() g_slice_new (GSList) | | ------------------ | | | | 46| 0|#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type))) | | ------------------ ------------------ 620| 0| last = last->next; 621| 0| if (func) ------------------ | Branch (621:15): [True: 0, False: 0] ------------------ 622| 0| last->data = func (list->data, user_data); 623| 0| else 624| 0| last->data = list->data; 625| 0| list = list->next; 626| 0| } 627| 1| last->next = NULL; 628| 1| } 629| | 630| 4| return new_list; 631| 4|} g_slist_find: 713| 3.86k|{ 714| 3.87k| while (list) ------------------ | Branch (714:10): [True: 6, False: 3.86k] ------------------ 715| 6| { 716| 6| if (list->data == data) ------------------ | Branch (716:11): [True: 0, False: 6] ------------------ 717| 0| break; 718| 6| list = list->next; 719| 6| } 720| | 721| 3.86k| return list; 722| 3.86k|} g_slist_foreach: 881| 3.85k|{ 882| 7.70k| while (list) ------------------ | Branch (882:10): [True: 3.85k, False: 3.85k] ------------------ 883| 3.85k| { 884| 3.85k| GSList *next = list->next; 885| 3.85k| (*func) (list->data, user_data); 886| 3.85k| list = next; 887| 3.85k| } 888| 3.85k|} g_slist_sort: 1068| 6|{ 1069| | return g_slist_sort_real (list, (GFunc) compare_func, NULL); 1070| 6|} gslist.c:_g_slist_remove_data: 417| 15|{ 418| 15| GSList *tmp = NULL; 419| 15| GSList **previous_ptr = &list; 420| | 421| 15| while (*previous_ptr) ------------------ | Branch (421:10): [True: 15, False: 0] ------------------ 422| 15| { 423| 15| tmp = *previous_ptr; 424| 15| if (tmp->data == data) ------------------ | Branch (424:11): [True: 15, False: 0] ------------------ 425| 15| { 426| 15| *previous_ptr = tmp->next; 427| 15| g_slist_free_1 (tmp); 428| 15| if (!all) ------------------ | Branch (428:15): [True: 15, False: 0] ------------------ 429| 15| break; 430| 15| } 431| 0| else 432| 0| { 433| 0| previous_ptr = &tmp->next; 434| 0| } 435| 15| } 436| | 437| 15| return list; 438| 15|} gslist.c:g_slist_sort_real: 1025| 6|{ 1026| 6| GSList *l1, *l2; 1027| | 1028| 6| if (!list) ------------------ | Branch (1028:7): [True: 6, False: 0] ------------------ 1029| 6| return NULL; 1030| 0| if (!list->next) ------------------ | Branch (1030:7): [True: 0, False: 0] ------------------ 1031| 0| return list; 1032| | 1033| 0| l1 = list; 1034| 0| l2 = list->next; 1035| | 1036| 0| while ((l2 = l2->next) != NULL) ------------------ | Branch (1036:10): [True: 0, False: 0] ------------------ 1037| 0| { 1038| 0| if ((l2 = l2->next) == NULL) ------------------ | Branch (1038:11): [True: 0, False: 0] ------------------ 1039| 0| break; 1040| 0| l1=l1->next; 1041| 0| } 1042| 0| l2 = l1->next; 1043| 0| l1->next = NULL; 1044| | 1045| 0| return g_slist_sort_merge (g_slist_sort_real (list, compare_func, user_data), 1046| 0| g_slist_sort_real (l2, compare_func, user_data), 1047| 0| compare_func, 1048| 0| user_data); 1049| 0|} g_strdup: 357| 4.11k|{ 358| 4.11k| gchar *new_str; 359| 4.11k| gsize length; 360| | 361| 4.11k| if (str) ------------------ | Branch (361:7): [True: 3.89k, False: 220] ------------------ 362| 3.89k| { 363| 3.89k| length = strlen (str) + 1; 364| 3.89k| new_str = g_new (char, length); ------------------ | | 290| 3.89k|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 3.89k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.89k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 3.89k| gsize __n = (gsize) (n_structs); \ | | | | 237| 3.89k| gsize __s = sizeof (struct_type); \ | | | | 238| 3.89k| gpointer __p; \ | | | | 239| 3.89k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 3.89k, False: 0] | | | | ------------------ | | | | 240| 3.89k| __p = g_##func (__n); \ | | | | 241| 3.89k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 3.89k| __p; \ | | | | 247| 3.89k| })) | | ------------------ ------------------ 365| 3.89k| memcpy (new_str, str, length); 366| 3.89k| } 367| 220| else 368| 220| new_str = NULL; 369| | 370| 4.11k| return new_str; 371| 4.11k|} g_memdup2: 422| 819|{ 423| 819| gpointer new_mem; 424| | 425| 819| if (mem && byte_size != 0) ------------------ | Branch (425:7): [True: 819, False: 0] | Branch (425:14): [True: 819, False: 0] ------------------ 426| 819| { 427| 819| new_mem = g_malloc (byte_size); 428| 819| memcpy (new_mem, mem, byte_size); 429| 819| } 430| 0| else 431| 0| new_mem = NULL; 432| | 433| 819| return new_mem; 434| 819|} g_strndup: 456| 2.92k|{ 457| 2.92k| gchar *new_str; 458| | 459| 2.92k| if (str) ------------------ | Branch (459:7): [True: 2.92k, False: 0] ------------------ 460| 2.92k| { 461| 2.92k| new_str = g_new (gchar, n + 1); ------------------ | | 290| 2.92k|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 2.92k| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2.92k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2.92k| gsize __n = (gsize) (n_structs); \ | | | | 237| 2.92k| gsize __s = sizeof (struct_type); \ | | | | 238| 2.92k| gpointer __p; \ | | | | 239| 2.92k| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 2.92k, False: 0] | | | | ------------------ | | | | 240| 2.92k| __p = g_##func (__n); \ | | | | 241| 2.92k| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 2.92k| __p; \ | | | | 247| 2.92k| })) | | ------------------ ------------------ 462| 2.92k| strncpy (new_str, str, n); 463| 2.92k| new_str[n] = '\0'; 464| 2.92k| } 465| 0| else 466| 0| new_str = NULL; 467| | 468| 2.92k| return new_str; 469| 2.92k|} g_strdup_vprintf: 551| 257k|{ 552| 257k| gchar *string = NULL; 553| | 554| 257k| g_vasprintf (&string, format, args); 555| | 556| 257k| return string; 557| 257k|} g_strdup_printf: 579| 339|{ 580| 339| gchar *buffer; 581| 339| va_list args; 582| | 583| 339| va_start (args, format); 584| 339| buffer = g_strdup_vprintf (format, args); 585| 339| va_end (args); 586| | 587| 339| return buffer; 588| 339|} g_ascii_strtoull: 1212| 548|{ 1213| 548|#ifdef USE_XLOCALE 1214| 548| return strtoull_l (nptr, endptr, base, get_C_locale ()); 1215| |#else 1216| | gboolean negative; 1217| | guint64 result; 1218| | 1219| | result = g_parse_long_long (nptr, (const gchar **) endptr, base, &negative); 1220| | 1221| | /* Return the result of the appropriate sign. */ 1222| | return negative ? -result : result; 1223| |#endif 1224| 548|} g_ascii_tolower: 1757| 228|{ 1758| 228| return g_ascii_isupper (c) ? c - 'A' + 'a' : c; ------------------ | | 84| 228| ((g_ascii_table[(guchar) (c)] & G_ASCII_UPPER) != 0) | | ------------------ | | | Branch (84:3): [True: 15, False: 213] | | ------------------ ------------------ 1759| 228|} g_strsplit: 2390| 88|{ 2391| 88| char *s; 2392| 88| const gchar *remainder; 2393| 88| GPtrArray *string_list; 2394| | 2395| 88| g_return_val_if_fail (string != NULL, NULL); ------------------ | | 643| 88| G_STMT_START { \ | | ------------------ | | | | 874| 88|#define G_STMT_START do | | ------------------ | | 644| 88| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 88|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 88| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 88|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 88| int _g_boolean_var_; \ | | | | | | 1018| 88| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 88, False: 0] | | | | | | ------------------ | | | | | | 1019| 88| _g_boolean_var_ = 1; \ | | | | | | 1020| 88| else \ | | | | | | 1021| 88| _g_boolean_var_ = 0; \ | | | | | | 1022| 88| _g_boolean_var_; \ | | | | | | 1023| 88|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 88, False: 0] | | | | ------------------ | | ------------------ | | 645| 88| { } \ | | 646| 88| else \ | | 647| 88| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 88| } G_STMT_END | | ------------------ | | | | 882| 88|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 88] | | | | ------------------ | | ------------------ ------------------ 2396| 88| g_return_val_if_fail (delimiter != NULL, NULL); ------------------ | | 643| 88| G_STMT_START { \ | | ------------------ | | | | 874| 88|#define G_STMT_START do | | ------------------ | | 644| 88| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 88|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 88| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 88|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 88| int _g_boolean_var_; \ | | | | | | 1018| 88| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 88, False: 0] | | | | | | ------------------ | | | | | | 1019| 88| _g_boolean_var_ = 1; \ | | | | | | 1020| 88| else \ | | | | | | 1021| 88| _g_boolean_var_ = 0; \ | | | | | | 1022| 88| _g_boolean_var_; \ | | | | | | 1023| 88|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 88, False: 0] | | | | ------------------ | | ------------------ | | 645| 88| { } \ | | 646| 88| else \ | | 647| 88| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 88| } G_STMT_END | | ------------------ | | | | 882| 88|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 88] | | | | ------------------ | | ------------------ ------------------ 2397| 88| g_return_val_if_fail (delimiter[0] != '\0', NULL); ------------------ | | 643| 88| G_STMT_START { \ | | ------------------ | | | | 874| 88|#define G_STMT_START do | | ------------------ | | 644| 88| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 88|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 88| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 88|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 88| int _g_boolean_var_; \ | | | | | | 1018| 88| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 88, False: 0] | | | | | | ------------------ | | | | | | 1019| 88| _g_boolean_var_ = 1; \ | | | | | | 1020| 88| else \ | | | | | | 1021| 88| _g_boolean_var_ = 0; \ | | | | | | 1022| 88| _g_boolean_var_; \ | | | | | | 1023| 88|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 88, False: 0] | | | | ------------------ | | ------------------ | | 645| 88| { } \ | | 646| 88| else \ | | 647| 88| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 88| } G_STMT_END | | ------------------ | | | | 882| 88|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 88] | | | | ------------------ | | ------------------ ------------------ 2398| | 2399| 88| if (max_tokens < 1) ------------------ | Branch (2399:7): [True: 0, False: 88] ------------------ 2400| 0| max_tokens = G_MAXINT; ------------------ | | 34| 0|#define G_MAXINT INT_MAX ------------------ 2401| | 2402| 88| string_list = g_ptr_array_new (); 2403| 88| remainder = string; 2404| 88| s = strstr (remainder, delimiter); 2405| 88| if (s) ------------------ | Branch (2405:7): [True: 87, False: 1] ------------------ 2406| 87| { 2407| 87| gsize delimiter_len = strlen (delimiter); 2408| | 2409| 429| while (--max_tokens && s) ------------------ | Branch (2409:14): [True: 345, False: 84] | Branch (2409:30): [True: 342, False: 3] ------------------ 2410| 342| { 2411| 342| gsize len; 2412| | 2413| 342| len = s - remainder; 2414| 342| g_ptr_array_add (string_list, g_strndup (remainder, len)); 2415| 342| remainder = s + delimiter_len; 2416| 342| s = strstr (remainder, delimiter); 2417| 342| } 2418| 87| } 2419| 88| if (*string) ------------------ | Branch (2419:7): [True: 88, False: 0] ------------------ 2420| 88| g_ptr_array_add (string_list, g_strdup (remainder)); 2421| | 2422| 88| g_ptr_array_add (string_list, NULL); 2423| | 2424| 88| return (char **) g_ptr_array_free (string_list, FALSE); ------------------ | | 814| 88|#define FALSE (0) ------------------ 2425| 88|} g_strfreev: 2547| 88|{ 2548| 88| if (str_array) ------------------ | Branch (2548:7): [True: 88, False: 0] ------------------ 2549| 88| { 2550| 88| gsize i; 2551| | 2552| 518| for (i = 0; str_array[i] != NULL; i++) ------------------ | Branch (2552:19): [True: 430, False: 88] ------------------ 2553| 430| g_free (str_array[i]); 2554| | 2555| 88| g_free (str_array); 2556| 88| } 2557| 88|} g_strv_length: 2950| 88|{ 2951| 88| guint i = 0; 2952| | 2953| 88| g_return_val_if_fail (str_array != NULL, 0); ------------------ | | 643| 88| G_STMT_START { \ | | ------------------ | | | | 874| 88|#define G_STMT_START do | | ------------------ | | 644| 88| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 88|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 88| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 88|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 88| int _g_boolean_var_; \ | | | | | | 1018| 88| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 88, False: 0] | | | | | | ------------------ | | | | | | 1019| 88| _g_boolean_var_ = 1; \ | | | | | | 1020| 88| else \ | | | | | | 1021| 88| _g_boolean_var_ = 0; \ | | | | | | 1022| 88| _g_boolean_var_; \ | | | | | | 1023| 88|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 88, False: 0] | | | | ------------------ | | ------------------ | | 645| 88| { } \ | | 646| 88| else \ | | 647| 88| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 88| } G_STMT_END | | ------------------ | | | | 882| 88|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 88] | | | | ------------------ | | ------------------ ------------------ 2954| | 2955| 518| while (str_array[i]) ------------------ | Branch (2955:10): [True: 430, False: 88] ------------------ 2956| 430| ++i; 2957| | 2958| 88| return i; 2959| 88|} g_ascii_string_to_unsigned: 3426| 548|{ 3427| 548| guint64 number; 3428| 548| const gchar *end_ptr = NULL; 3429| 548| gint saved_errno = 0; 3430| | 3431| 548| g_return_val_if_fail (str != NULL, FALSE); ------------------ | | 643| 548| G_STMT_START { \ | | ------------------ | | | | 874| 548|#define G_STMT_START do | | ------------------ | | 644| 548| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 548|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 548| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 548|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 548| int _g_boolean_var_; \ | | | | | | 1018| 548| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 548, False: 0] | | | | | | ------------------ | | | | | | 1019| 548| _g_boolean_var_ = 1; \ | | | | | | 1020| 548| else \ | | | | | | 1021| 548| _g_boolean_var_ = 0; \ | | | | | | 1022| 548| _g_boolean_var_; \ | | | | | | 1023| 548|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 548, False: 0] | | | | ------------------ | | ------------------ | | 645| 548| { } \ | | 646| 548| else \ | | 647| 548| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 548| } G_STMT_END | | ------------------ | | | | 882| 548|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 548] | | | | ------------------ | | ------------------ ------------------ 3432| 548| g_return_val_if_fail (base >= 2 && base <= 36, FALSE); ------------------ | | 643| 548| G_STMT_START { \ | | ------------------ | | | | 874| 548|#define G_STMT_START do | | ------------------ | | 644| 548| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 548|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 548| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 548|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 548| int _g_boolean_var_; \ | | | | | | 1018| 1.64k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 548, False: 0] | | | | | | | Branch (1018:8): [True: 548, False: 0] | | | | | | ------------------ | | | | | | 1019| 548| _g_boolean_var_ = 1; \ | | | | | | 1020| 548| else \ | | | | | | 1021| 548| _g_boolean_var_ = 0; \ | | | | | | 1022| 548| _g_boolean_var_; \ | | | | | | 1023| 548|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 548, False: 0] | | | | ------------------ | | ------------------ | | 645| 548| { } \ | | 646| 548| else \ | | 647| 548| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 548| } G_STMT_END | | ------------------ | | | | 882| 548|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 548] | | | | ------------------ | | ------------------ ------------------ 3433| 548| g_return_val_if_fail (min <= max, FALSE); ------------------ | | 643| 548| G_STMT_START { \ | | ------------------ | | | | 874| 548|#define G_STMT_START do | | ------------------ | | 644| 548| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 548|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 548| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 548|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 548| int _g_boolean_var_; \ | | | | | | 1018| 548| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 548, False: 0] | | | | | | ------------------ | | | | | | 1019| 548| _g_boolean_var_ = 1; \ | | | | | | 1020| 548| else \ | | | | | | 1021| 548| _g_boolean_var_ = 0; \ | | | | | | 1022| 548| _g_boolean_var_; \ | | | | | | 1023| 548|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 548, False: 0] | | | | ------------------ | | ------------------ | | 645| 548| { } \ | | 646| 548| else \ | | 647| 548| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 548| } G_STMT_END | | ------------------ | | | | 882| 548|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 548] | | | | ------------------ | | ------------------ ------------------ 3434| 548| g_return_val_if_fail (error == NULL || *error == NULL, FALSE); ------------------ | | 643| 548| G_STMT_START { \ | | ------------------ | | | | 874| 548|#define G_STMT_START do | | ------------------ | | 644| 548| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 548|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 548| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 548|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 548| int _g_boolean_var_; \ | | | | | | 1018| 1.09k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 548, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 548| _g_boolean_var_ = 1; \ | | | | | | 1020| 548| else \ | | | | | | 1021| 548| _g_boolean_var_ = 0; \ | | | | | | 1022| 548| _g_boolean_var_; \ | | | | | | 1023| 548|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 548, False: 0] | | | | ------------------ | | ------------------ | | 645| 548| { } \ | | 646| 548| else \ | | 647| 548| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 548| } G_STMT_END | | ------------------ | | | | 882| 548|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 548] | | | | ------------------ | | ------------------ ------------------ 3435| | 3436| 548| if (str[0] == '\0') ------------------ | Branch (3436:7): [True: 0, False: 548] ------------------ 3437| 0| { 3438| 0| g_set_error_literal (error, 3439| 0| G_NUMBER_PARSER_ERROR, G_NUMBER_PARSER_ERROR_INVALID, ------------------ | | 343| 0|#define G_NUMBER_PARSER_ERROR (g_number_parser_error_quark ()) ------------------ 3440| 0| _("Empty string is not a number")); ------------------ | | 17| 0|#define _(String) glib_gettext(String) ------------------ 3441| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 3442| 0| } 3443| | 3444| 548| errno = 0; 3445| 548| number = g_ascii_strtoull (str, (gchar **)&end_ptr, base); 3446| 548| saved_errno = errno; 3447| | 3448| 548| if (/* We do not allow leading whitespace, but g_ascii_strtoull 3449| | * accepts it and just skips it, so we need to check for it 3450| | * ourselves. 3451| | */ 3452| 548| g_ascii_isspace (str[0]) || ------------------ | | 81| 1.09k| ((g_ascii_table[(guchar) (c)] & G_ASCII_SPACE) != 0) | | ------------------ | | | Branch (81:3): [True: 1, False: 547] | | ------------------ ------------------ 3453| | /* Unsigned number should have no sign. 3454| | */ 3455| 547| str_has_sign (str) || ------------------ | Branch (3455:7): [True: 3, False: 544] ------------------ 3456| | /* We don't support hexadecimal numbers prefixed with 0x or 3457| | * 0X. 3458| | */ 3459| 544| (base == 16 && str_has_hex_prefix (str)) || ------------------ | Branch (3459:8): [True: 544, False: 0] | Branch (3459:22): [True: 1, False: 543] ------------------ 3460| 543| (saved_errno != 0 && saved_errno != ERANGE) || ------------------ | Branch (3460:8): [True: 0, False: 543] | Branch (3460:28): [True: 0, False: 0] ------------------ 3461| 543| end_ptr == NULL || ------------------ | Branch (3461:7): [True: 0, False: 543] ------------------ 3462| 543| *end_ptr != '\0') ------------------ | Branch (3462:7): [True: 18, False: 525] ------------------ 3463| 23| { 3464| 23| g_set_error (error, 3465| 23| G_NUMBER_PARSER_ERROR, G_NUMBER_PARSER_ERROR_INVALID, ------------------ | | 343| 23|#define G_NUMBER_PARSER_ERROR (g_number_parser_error_quark ()) ------------------ 3466| 23| _("“%s” is not an unsigned number"), str); ------------------ | | 17| 23|#define _(String) glib_gettext(String) ------------------ 3467| 23| return FALSE; ------------------ | | 814| 23|#define FALSE (0) ------------------ 3468| 23| } 3469| 525| if (saved_errno == ERANGE || number < min || number > max) ------------------ | Branch (3469:7): [True: 0, False: 525] | Branch (3469:32): [True: 0, False: 525] | Branch (3469:48): [True: 0, False: 525] ------------------ 3470| 0| { 3471| 0| gchar *min_str = g_strdup_printf ("%" G_GUINT64_FORMAT, min); ------------------ | | 69| 0|#define G_GUINT64_FORMAT "lu" ------------------ 3472| 0| gchar *max_str = g_strdup_printf ("%" G_GUINT64_FORMAT, max); ------------------ | | 69| 0|#define G_GUINT64_FORMAT "lu" ------------------ 3473| | 3474| 0| g_set_error (error, 3475| 0| G_NUMBER_PARSER_ERROR, G_NUMBER_PARSER_ERROR_OUT_OF_BOUNDS, ------------------ | | 343| 0|#define G_NUMBER_PARSER_ERROR (g_number_parser_error_quark ()) ------------------ 3476| 0| _("Number “%s” is out of bounds [%s, %s]"), ------------------ | | 17| 0|#define _(String) glib_gettext(String) ------------------ 3477| 0| str, min_str, max_str); 3478| 0| g_free (min_str); 3479| 0| g_free (max_str); 3480| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 3481| 0| } 3482| 525| if (out_num != NULL) ------------------ | Branch (3482:7): [True: 525, False: 0] ------------------ 3483| 525| *out_num = number; 3484| 525| return TRUE; ------------------ | | 818| 525|#define TRUE (!FALSE) | | ------------------ | | | | 814| 525|#define FALSE (0) | | ------------------ ------------------ 3485| 525|} gstrfuncs.c:get_C_locale: 331| 548|{ 332| 548| static gsize initialized = FALSE; ------------------ | | 814| 548|#define FALSE (0) ------------------ 333| 548| static locale_t C_locale = NULL; 334| | 335| 548| if (g_once_init_enter (&initialized)) ------------------ | | 257| 548| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 548|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | | Branch (257:3): [True: 1, False: 547] | | ------------------ | | 258| 548| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 548|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 259| 548| (void) (0 ? (gpointer) *(location) : NULL); \ | | ------------------ | | | Branch (259:13): [Folded, False: 548] | | ------------------ | | 260| 548| (!g_atomic_pointer_get (location) && \ | | ------------------ | | | | 113| 1.09k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 548|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 1.09k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 548|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 1.09k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 548|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 1.09k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 548|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 1.09k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 1.09k| gapg_temp_newval; \ | | | | 119| 1.09k| })) | | ------------------ | | | Branch (260:6): [True: 1, False: 547] | | ------------------ | | 261| 548| g_once_init_enter (location)); \ | | ------------------ | | | Branch (261:6): [True: 1, False: 0] | | ------------------ | | 262| 548| })) ------------------ 336| 1| { 337| 1| C_locale = newlocale (LC_ALL_MASK, "C", NULL); 338| 1| g_once_init_leave (&initialized, TRUE); ------------------ | | 264| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 265| 1| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 266| 1| 0 ? (void) (*(location) = (result)) : (void) 0; \ | | ------------------ | | | Branch (266:5): [Folded, False: 1] | | ------------------ | | 267| 1| g_once_init_leave ((location), (gsize) (result)); \ | | 268| 1| })) ------------------ 339| 1| } 340| | 341| 548| return C_locale; 342| 548|} gstrfuncs.c:str_has_sign: 3272| 547|{ 3273| 547| return str[0] == '-' || str[0] == '+'; ------------------ | Branch (3273:10): [True: 2, False: 545] | Branch (3273:27): [True: 1, False: 544] ------------------ 3274| 547|} gstrfuncs.c:str_has_hex_prefix: 3278| 544|{ 3279| 544| return str[0] == '0' && g_ascii_tolower (str[1]) == 'x'; ------------------ | Branch (3279:10): [True: 228, False: 316] | Branch (3279:27): [True: 1, False: 227] ------------------ 3280| 544|} g_strcmp0: 3225| 741|{ 3226| 741| if (!str1) ------------------ | Branch (3226:7): [True: 354, False: 387] ------------------ 3227| 354| return -(str1 != str2); 3228| 387| if (!str2) ------------------ | Branch (3228:7): [True: 0, False: 387] ------------------ 3229| 0| return str1 != str2; 3230| 387| return strcmp (str1, str2); 3231| 387|} g_rec_mutex_lock: 394| 13|{ 395| 13| pthread_mutex_lock (g_rec_mutex_get_impl (mutex)); 396| 13|} g_rec_mutex_unlock: 413| 13|{ 414| 13| pthread_mutex_unlock (rec_mutex->p); 415| 13|} g_rw_lock_writer_lock: 551| 144|{ 552| 144| int retval = pthread_rwlock_wrlock (g_rw_lock_get_impl (rw_lock)); 553| | 554| 144| if (retval != 0) ------------------ | Branch (554:7): [True: 0, False: 144] ------------------ 555| 0| g_critical ("Failed to get RW lock %p: %s", rw_lock, g_strerror (retval)); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 556| 144|} g_rw_lock_writer_unlock: 593| 144|{ 594| 144| pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock)); 595| 144|} g_rw_lock_reader_lock: 621| 152|{ 622| 152| int retval = pthread_rwlock_rdlock (g_rw_lock_get_impl (rw_lock)); 623| | 624| 152| if (retval != 0) ------------------ | Branch (624:7): [True: 0, False: 152] ------------------ 625| 0| g_critical ("Failed to get RW lock %p: %s", rw_lock, g_strerror (retval)); ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 626| 152|} g_rw_lock_reader_unlock: 662| 152|{ 663| 152| pthread_rwlock_unlock (g_rw_lock_get_impl (rw_lock)); 664| 152|} g_private_get: 1080| 674k|{ 1081| | /* quote POSIX: No errors are returned from pthread_getspecific(). */ 1082| 674k| return pthread_getspecific (*g_private_get_impl (key)); 1083| 674k|} g_private_set: 1099| 1.02M|{ 1100| 1.02M| gint status; 1101| | 1102| 1.02M| if G_UNLIKELY ((status = pthread_setspecific (*g_private_get_impl (key), value)) != 0) ------------------ | | 1025| 1.02M|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 1.02M| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1.02M|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 1.02M| int _g_boolean_var_; \ | | | | 1018| 1.02M| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 1.02M] | | | | ------------------ | | | | 1019| 1.02M| _g_boolean_var_ = 1; \ | | | | 1020| 1.02M| else \ | | | | 1021| 1.02M| _g_boolean_var_ = 0; \ | | | | 1022| 1.02M| _g_boolean_var_; \ | | | | 1023| 1.02M|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 1.02M] | | ------------------ ------------------ 1103| 0| g_thread_abort (status, "pthread_setspecific"); 1104| 1.02M|} g_mutex_lock: 1513| 545k|{ 1514| | /* 0 -> 1 and we're done. Anything else, and we need to wait... */ 1515| 545k| if G_UNLIKELY (g_atomic_int_add (&mutex->i[0], 1) != 0) ------------------ | | 1025| 545k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 545k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 545k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 545k| int _g_boolean_var_; \ | | | | 1018| 1.63M| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [Folded, False: 545k] | | | | | Branch (1018:8): [True: 0, False: 545k] | | | | ------------------ | | | | 1019| 545k| _g_boolean_var_ = 1; \ | | | | 1020| 545k| else \ | | | | 1021| 545k| _g_boolean_var_ = 0; \ | | | | 1022| 545k| _g_boolean_var_; \ | | | | 1023| 545k|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 545k] | | ------------------ ------------------ 1516| 0| g_mutex_lock_slowpath (mutex); 1517| 545k|} g_mutex_unlock: 1521| 545k|{ 1522| 545k| guint prev; 1523| | 1524| 545k| prev = exchange_release (&mutex->i[0], 0); ------------------ | | 1425| 545k| atomic_exchange_explicit((atomic_uint *) (ptr), (new), __ATOMIC_RELEASE) ------------------ 1525| | 1526| | /* 1-> 0 and we're done. Anything else and we need to signal... */ 1527| 545k| if G_UNLIKELY (prev != 1) ------------------ | | 1025| 545k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 545k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 545k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 545k| int _g_boolean_var_; \ | | | | 1018| 545k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 545k] | | | | ------------------ | | | | 1019| 545k| _g_boolean_var_ = 1; \ | | | | 1020| 545k| else \ | | | | 1021| 545k| _g_boolean_var_ = 0; \ | | | | 1022| 545k| _g_boolean_var_; \ | | | | 1023| 545k|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 545k] | | ------------------ ------------------ 1528| 0| g_mutex_unlock_slowpath (mutex, prev); 1529| 545k|} g_mutex_trylock: 1533| 168|{ 1534| 168| guint zero = 0; 1535| | 1536| | /* We don't want to touch the value at all unless we can move it from 1537| | * exactly 0 to 1. 1538| | */ 1539| | return compare_exchange_acquire (&mutex->i[0], &zero, 1); ------------------ | | 1421| 168| atomic_compare_exchange_strong_explicit((atomic_uint *) (ptr), (old), (new), \ | | 1422| 168| __ATOMIC_ACQUIRE, __ATOMIC_RELAXED) ------------------ 1540| 168|} g_cond_broadcast: 1588| 15|{ 1589| 15| g_atomic_int_inc (&cond->i[0]); ------------------ | | 148| 15| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 15|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 149| 15| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 15|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 150| 15| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (150:13): [Folded, False: 15] | | ------------------ | | 151| 15| (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ | | 152| 15| })) ------------------ 1590| | 1591| 15| syscall (__NR_futex, &cond->i[0], (gsize) FUTEX_WAKE_PRIVATE, (gsize) INT_MAX, NULL); 1592| 15|} gthread-posix.c:g_rec_mutex_impl_new: 280| 1|{ 281| 1| pthread_mutexattr_t attr; 282| 1| pthread_mutex_t *mutex; 283| | 284| 1| mutex = malloc (sizeof (pthread_mutex_t)); 285| 1| if G_UNLIKELY (mutex == NULL) ------------------ | | 1025| 1|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 1| int _g_boolean_var_; \ | | | | 1018| 1| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 1] | | | | ------------------ | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | 1020| 1| else \ | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | 1022| 1| _g_boolean_var_; \ | | | | 1023| 1|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 1] | | ------------------ ------------------ 286| 0| g_thread_abort (errno, "malloc"); 287| | 288| 1| pthread_mutexattr_init (&attr); 289| 1| pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE); 290| 1| pthread_mutex_init (mutex, &attr); 291| 1| pthread_mutexattr_destroy (&attr); 292| | 293| 1| return mutex; 294| 1|} gthread-posix.c:g_rec_mutex_get_impl: 305| 13|{ 306| 13| pthread_mutex_t *impl = g_atomic_pointer_get (&rec_mutex->p); ------------------ | | 113| 13| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 13|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 114| 13| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 13|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 115| 13| glib_typeof (*(atomic)) gapg_temp_newval; \ | | ------------------ | | | | 238| 13|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 116| 13| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 13|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 117| 13| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | 118| 13| gapg_temp_newval; \ | | 119| 13| })) ------------------ 307| | 308| 13| if G_UNLIKELY (impl == NULL) ------------------ | | 1025| 13|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 13| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 13|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 13| int _g_boolean_var_; \ | | | | 1018| 13| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 1, False: 12] | | | | ------------------ | | | | 1019| 13| _g_boolean_var_ = 1; \ | | | | 1020| 13| else \ | | | | 1021| 13| _g_boolean_var_ = 0; \ | | | | 1022| 13| _g_boolean_var_; \ | | | | 1023| 13|}) | | ------------------ | | | Branch (1025:27): [True: 1, False: 12] | | ------------------ ------------------ 309| 1| { 310| 1| impl = g_rec_mutex_impl_new (); 311| 1| if (!g_atomic_pointer_compare_and_exchange (&rec_mutex->p, NULL, impl)) ------------------ | | 210| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 211| 1| G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 212| 1| gpointer gapcae_oldval = (gpointer)(oldval); \ | | 213| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 214| 1| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | ------------------ | | | Branch (214:13): [Folded, False: 1] | | ------------------ | | 215| 1| __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 818| 1|#define TRUE (!FALSE) | | | | ------------------ | | | | | | 814| 1|#define FALSE (0) | | | | ------------------ | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (215:5): [True: 1, False: 0] | | ------------------ | | 216| 1| })) ------------------ | Branch (311:11): [True: 0, False: 1] ------------------ 312| 0| g_rec_mutex_impl_free (impl); 313| 1| impl = rec_mutex->p; 314| 1| } 315| | 316| 13| return impl; 317| 13|} gthread-posix.c:g_rw_lock_impl_new: 442| 2|{ 443| 2| pthread_rwlock_t *rwlock; 444| 2| gint status; 445| | 446| 2| rwlock = malloc (sizeof (pthread_rwlock_t)); 447| 2| if G_UNLIKELY (rwlock == NULL) ------------------ | | 1025| 2|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2| int _g_boolean_var_; \ | | | | 1018| 2| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 2] | | | | ------------------ | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | 1020| 2| else \ | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | 1022| 2| _g_boolean_var_; \ | | | | 1023| 2|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 2] | | ------------------ ------------------ 448| 0| g_thread_abort (errno, "malloc"); 449| | 450| 2| if G_UNLIKELY ((status = pthread_rwlock_init (rwlock, NULL)) != 0) ------------------ | | 1025| 2|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2| int _g_boolean_var_; \ | | | | 1018| 2| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 2] | | | | ------------------ | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | 1020| 2| else \ | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | 1022| 2| _g_boolean_var_; \ | | | | 1023| 2|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 2] | | ------------------ ------------------ 451| 0| g_thread_abort (status, "pthread_rwlock_init"); 452| | 453| 2| return rwlock; 454| 2|} gthread-posix.c:g_rw_lock_get_impl: 465| 592|{ 466| 592| pthread_rwlock_t *impl = g_atomic_pointer_get (&lock->p); ------------------ | | 113| 592| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 592|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 114| 592| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 592|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 115| 592| glib_typeof (*(atomic)) gapg_temp_newval; \ | | ------------------ | | | | 238| 592|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 116| 592| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 592|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 117| 592| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | 118| 592| gapg_temp_newval; \ | | 119| 592| })) ------------------ 467| | 468| 592| if G_UNLIKELY (impl == NULL) ------------------ | | 1025| 592|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 592| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 592|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 592| int _g_boolean_var_; \ | | | | 1018| 592| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 2, False: 590] | | | | ------------------ | | | | 1019| 592| _g_boolean_var_ = 1; \ | | | | 1020| 592| else \ | | | | 1021| 592| _g_boolean_var_ = 0; \ | | | | 1022| 592| _g_boolean_var_; \ | | | | 1023| 592|}) | | ------------------ | | | Branch (1025:27): [True: 2, False: 590] | | ------------------ ------------------ 469| 2| { 470| 2| impl = g_rw_lock_impl_new (); 471| 2| if (!g_atomic_pointer_compare_and_exchange (&lock->p, NULL, impl)) ------------------ | | 210| 2| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 211| 2| G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 2|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 212| 2| gpointer gapcae_oldval = (gpointer)(oldval); \ | | 213| 2| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 2|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 214| 2| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | ------------------ | | | Branch (214:13): [Folded, False: 2] | | ------------------ | | 215| 2| __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 2|#define FALSE (0) | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 818| 2|#define TRUE (!FALSE) | | | | ------------------ | | | | | | 814| 2|#define FALSE (0) | | | | ------------------ | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (215:5): [True: 2, False: 0] | | ------------------ | | 216| 2| })) ------------------ | Branch (471:11): [True: 0, False: 2] ------------------ 472| 0| g_rw_lock_impl_free (impl); 473| 2| impl = lock->p; 474| 2| } 475| | 476| 592| return impl; 477| 592|} gthread-posix.c:g_private_get_impl: 1050| 1.70M|{ 1051| 1.70M| pthread_key_t *impl = g_atomic_pointer_get (&key->p); ------------------ | | 113| 1.70M| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1.70M|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 114| 1.70M| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1.70M|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 115| 1.70M| glib_typeof (*(atomic)) gapg_temp_newval; \ | | ------------------ | | | | 238| 1.70M|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 116| 1.70M| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 1.70M|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 117| 1.70M| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | 118| 1.70M| gapg_temp_newval; \ | | 119| 1.70M| })) ------------------ 1052| | 1053| 1.70M| if G_UNLIKELY (impl == NULL) ------------------ | | 1025| 1.70M|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 1.70M| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1.70M|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 1.70M| int _g_boolean_var_; \ | | | | 1018| 1.70M| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 4, False: 1.70M] | | | | ------------------ | | | | 1019| 1.70M| _g_boolean_var_ = 1; \ | | | | 1020| 1.70M| else \ | | | | 1021| 1.70M| _g_boolean_var_ = 0; \ | | | | 1022| 1.70M| _g_boolean_var_; \ | | | | 1023| 1.70M|}) | | ------------------ | | | Branch (1025:27): [True: 4, False: 1.70M] | | ------------------ ------------------ 1054| 4| { 1055| 4| impl = g_private_impl_new (key->notify); 1056| 4| if (!g_atomic_pointer_compare_and_exchange (&key->p, NULL, impl)) ------------------ | | 210| 4| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 4|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 211| 4| G_STATIC_ASSERT (sizeof (oldval) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 4|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 212| 4| gpointer gapcae_oldval = (gpointer)(oldval); \ | | 213| 4| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 4|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 214| 4| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | ------------------ | | | Branch (214:13): [Folded, False: 4] | | ------------------ | | 215| 4| __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 4|#define FALSE (0) | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 818| 4|#define TRUE (!FALSE) | | | | ------------------ | | | | | | 814| 4|#define FALSE (0) | | | | ------------------ | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gapcae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (215:5): [True: 4, False: 0] | | ------------------ | | 216| 4| })) ------------------ | Branch (1056:11): [True: 0, False: 4] ------------------ 1057| 0| { 1058| 0| g_private_impl_free (impl); 1059| 0| impl = key->p; 1060| 0| } 1061| 4| } 1062| | 1063| 1.70M| return impl; 1064| 1.70M|} gthread-posix.c:g_private_impl_new: 1023| 4|{ 1024| 4| pthread_key_t *key; 1025| 4| gint status; 1026| | 1027| 4| key = malloc (sizeof (pthread_key_t)); 1028| 4| if G_UNLIKELY (key == NULL) ------------------ | | 1025| 4|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 4| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 4|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 4| int _g_boolean_var_; \ | | | | 1018| 4| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 4] | | | | ------------------ | | | | 1019| 4| _g_boolean_var_ = 1; \ | | | | 1020| 4| else \ | | | | 1021| 4| _g_boolean_var_ = 0; \ | | | | 1022| 4| _g_boolean_var_; \ | | | | 1023| 4|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 4] | | ------------------ ------------------ 1029| 0| g_thread_abort (errno, "malloc"); 1030| 4| status = pthread_key_create (key, notify); 1031| 4| if G_UNLIKELY (status != 0) ------------------ | | 1025| 4|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 4| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 4|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 4| int _g_boolean_var_; \ | | | | 1018| 4| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 4] | | | | ------------------ | | | | 1019| 4| _g_boolean_var_ = 1; \ | | | | 1020| 4| else \ | | | | 1021| 4| _g_boolean_var_ = 0; \ | | | | 1022| 4| _g_boolean_var_; \ | | | | 1023| 4|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 4] | | ------------------ ------------------ 1032| 0| g_thread_abort (status, "pthread_key_create"); 1033| | 1034| 4| return key; 1035| 4|} g_private_set_alloc0: 540| 2|{ 541| 2| gpointer allocated = g_malloc0 (size); 542| | 543| 2| g_private_set (key, allocated); 544| | 545| 2| return g_steal_pointer (&allocated); ------------------ | | 222| 2|#define g_steal_pointer(pp) ((glib_typeof (*pp)) (g_steal_pointer) (pp)) ------------------ 546| 2|} g_once_init_enter: 699| 15|{ 700| 15| gsize *value_location = (gsize *) location; 701| 15| gboolean need_init = FALSE; ------------------ | | 814| 15|#define FALSE (0) ------------------ 702| 15| g_mutex_lock (&g_once_mutex); 703| 15| if (g_atomic_pointer_get (value_location) == 0) ------------------ | | 113| 15| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 15|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 114| 15| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 15|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 115| 15| glib_typeof (*(atomic)) gapg_temp_newval; \ | | ------------------ | | | | 238| 15|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 116| 15| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 15|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 117| 15| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | 118| 15| gapg_temp_newval; \ | | 119| 15| })) ------------------ | Branch (703:7): [True: 15, False: 0] ------------------ 704| 15| { 705| 15| if (!g_slist_find (g_once_init_list, (void*) value_location)) ------------------ | Branch (705:11): [True: 15, False: 0] ------------------ 706| 15| { 707| 15| need_init = TRUE; ------------------ | | 818| 15|#define TRUE (!FALSE) | | ------------------ | | | | 814| 15|#define FALSE (0) | | ------------------ ------------------ 708| 15| g_once_init_list = g_slist_prepend (g_once_init_list, (void*) value_location); 709| 15| } 710| 0| else 711| 0| do 712| 0| g_cond_wait (&g_once_cond, &g_once_mutex); 713| 0| while (g_slist_find (g_once_init_list, (void*) value_location)); ------------------ | Branch (713:16): [True: 0, False: 0] ------------------ 714| 15| } 715| 15| g_mutex_unlock (&g_once_mutex); 716| 15| return need_init; 717| 15|} g_once_init_leave: 739| 15|{ 740| 15| gsize *value_location = (gsize *) location; 741| | 742| 15| g_return_if_fail (g_atomic_pointer_get (value_location) == 0); ------------------ | | 630| 15| G_STMT_START { \ | | ------------------ | | | | 874| 15|#define G_STMT_START do | | ------------------ | | 631| 15| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 15|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 15| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 15|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 15| int _g_boolean_var_; \ | | | | | | 1018| 15| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 15, False: 0] | | | | | | ------------------ | | | | | | 1019| 15| _g_boolean_var_ = 1; \ | | | | | | 1020| 15| else \ | | | | | | 1021| 15| _g_boolean_var_ = 0; \ | | | | | | 1022| 15| _g_boolean_var_; \ | | | | | | 1023| 15|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 15, False: 0] | | | | ------------------ | | ------------------ | | 632| 15| { } \ | | 633| 15| else \ | | 634| 15| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 15| } G_STMT_END | | ------------------ | | | | 882| 15|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 15] | | | | ------------------ | | ------------------ ------------------ 743| 15| g_return_if_fail (result != 0); ------------------ | | 630| 15| G_STMT_START { \ | | ------------------ | | | | 874| 15|#define G_STMT_START do | | ------------------ | | 631| 15| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 15|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 15| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 15|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 15| int _g_boolean_var_; \ | | | | | | 1018| 15| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 15, False: 0] | | | | | | ------------------ | | | | | | 1019| 15| _g_boolean_var_ = 1; \ | | | | | | 1020| 15| else \ | | | | | | 1021| 15| _g_boolean_var_ = 0; \ | | | | | | 1022| 15| _g_boolean_var_; \ | | | | | | 1023| 15|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 15, False: 0] | | | | ------------------ | | ------------------ | | 632| 15| { } \ | | 633| 15| else \ | | 634| 15| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 15| } G_STMT_END | | ------------------ | | | | 882| 15|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 15] | | | | ------------------ | | ------------------ ------------------ 744| | 745| 15| g_atomic_pointer_set (value_location, result); ------------------ | | 121| 15| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 15|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 122| 15| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 15|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 123| 15| glib_typeof ((atomic)) gaps_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 15|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 124| 15| glib_typeof (*(atomic)) gaps_temp_newval = (newval); \ | | ------------------ | | | | 238| 15|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 125| 15| (void) (0 ? (gpointer) * (atomic) : NULL); \ | | ------------------ | | | Branch (125:13): [Folded, False: 15] | | ------------------ | | 126| 15| __atomic_store (gaps_temp_atomic, &gaps_temp_newval, __ATOMIC_SEQ_CST); \ | | 127| 15| })) ------------------ 746| 15| g_mutex_lock (&g_once_mutex); 747| 15| g_return_if_fail (g_once_init_list != NULL); ------------------ | | 630| 15| G_STMT_START { \ | | ------------------ | | | | 874| 15|#define G_STMT_START do | | ------------------ | | 631| 15| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 15|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 15| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 15|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 15| int _g_boolean_var_; \ | | | | | | 1018| 15| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 15, False: 0] | | | | | | ------------------ | | | | | | 1019| 15| _g_boolean_var_ = 1; \ | | | | | | 1020| 15| else \ | | | | | | 1021| 15| _g_boolean_var_ = 0; \ | | | | | | 1022| 15| _g_boolean_var_; \ | | | | | | 1023| 15|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 15, False: 0] | | | | ------------------ | | ------------------ | | 632| 15| { } \ | | 633| 15| else \ | | 634| 15| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 15| } G_STMT_END | | ------------------ | | | | 882| 15|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 15] | | | | ------------------ | | ------------------ ------------------ 748| 15| g_once_init_list = g_slist_remove (g_once_init_list, (void*) value_location); 749| 15| g_cond_broadcast (&g_once_cond); 750| 15| g_mutex_unlock (&g_once_mutex); 751| 15|} g_thread_n_created: 833| 7.70k|{ 834| 7.70k| return g_atomic_int_get (&g_thread_n_created_counter); ------------------ | | 96| 7.70k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 7.70k| gint gaig_temp; \ | | 99| 7.70k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 7.70k] | | ------------------ | | 100| 7.70k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 7.70k| (gint) gaig_temp; \ | | 102| 7.70k| })) ------------------ 835| 7.70k|} g_utf8_validate_len: 1711| 2.73k|{ 1712| 2.73k| const gchar *p; 1713| | 1714| 2.73k| p = fast_validate_len (str, max_len); 1715| | 1716| 2.73k| if (end) ------------------ | Branch (1716:7): [True: 0, False: 2.73k] ------------------ 1717| 0| *end = p; 1718| | 1719| 2.73k| if (p != str + max_len) ------------------ | Branch (1719:7): [True: 151, False: 2.58k] ------------------ 1720| 151| return FALSE; ------------------ | | 814| 151|#define FALSE (0) ------------------ 1721| 2.58k| else 1722| 2.58k| return TRUE; ------------------ | | 818| 2.58k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 2.58k|#define FALSE (0) | | ------------------ ------------------ 1723| 2.73k|} gutf8.c:fast_validate_len: 1567| 2.73k|{ 1568| 2.73k| const gchar *p; 1569| | 1570| 2.73k| g_assert (max_len >= 0); ------------------ | | 231| 2.73k|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2.73k|#define G_STMT_START do | | ------------------ | | 232| 2.73k| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2.73k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2.73k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2.73k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2.73k| int _g_boolean_var_; \ | | | | | | 1018| 2.73k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2.73k, False: 0] | | | | | | ------------------ | | | | | | 1019| 2.73k| _g_boolean_var_ = 1; \ | | | | | | 1020| 2.73k| else \ | | | | | | 1021| 2.73k| _g_boolean_var_ = 0; \ | | | | | | 1022| 2.73k| _g_boolean_var_; \ | | | | | | 1023| 2.73k|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2.73k, False: 0] | | | | ------------------ | | ------------------ | | 233| 2.73k| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2.73k| } G_STMT_END | | ------------------ | | | | 882| 2.73k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2.73k] | | | | ------------------ | | ------------------ ------------------ 1571| | 1572| 59.7k| for (p = str; ((p - str) < max_len) && *p; p++) ------------------ | Branch (1572:17): [True: 57.1k, False: 2.58k] | Branch (1572:42): [True: 57.1k, False: 4] ------------------ 1573| 57.1k| { 1574| 57.1k| if (*(guchar *)p < 128) ------------------ | Branch (1574:11): [True: 55.3k, False: 1.81k] ------------------ 1575| 55.3k| /* done */; 1576| 1.81k| else 1577| 1.81k| { 1578| 1.81k| const gchar *last; 1579| | 1580| 1.81k| last = p; 1581| 1.81k| if (*(guchar *)p < 0xe0) /* 110xxxxx */ ------------------ | Branch (1581:8): [True: 479, False: 1.33k] ------------------ 1582| 479| { 1583| 479| if (G_UNLIKELY (max_len - (p - str) < 2)) ------------------ | | 1025| 479|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 479| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 479|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 479| int _g_boolean_var_; \ | | | | 1018| 479| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 10, False: 469] | | | | ------------------ | | | | 1019| 479| _g_boolean_var_ = 1; \ | | | | 1020| 479| else \ | | | | 1021| 479| _g_boolean_var_ = 0; \ | | | | 1022| 479| _g_boolean_var_; \ | | | | 1023| 479|}) | | ------------------ | | | Branch (1025:26): [True: 10, False: 469] | | ------------------ ------------------ 1584| 10| goto error; 1585| | 1586| 469| if (G_UNLIKELY (*(guchar *)p < 0xc2)) ------------------ | | 1025| 469|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 469| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 469|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 469| int _g_boolean_var_; \ | | | | 1018| 469| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 22, False: 447] | | | | ------------------ | | | | 1019| 469| _g_boolean_var_ = 1; \ | | | | 1020| 469| else \ | | | | 1021| 469| _g_boolean_var_ = 0; \ | | | | 1022| 469| _g_boolean_var_; \ | | | | 1023| 469|}) | | ------------------ | | | Branch (1025:26): [True: 22, False: 447] | | ------------------ ------------------ 1587| 22| goto error; 1588| 469| } 1589| 1.33k| else 1590| 1.33k| { 1591| 1.33k| if (*(guchar *)p < 0xf0) /* 1110xxxx */ ------------------ | Branch (1591:12): [True: 366, False: 966] ------------------ 1592| 366| { 1593| 366| if (G_UNLIKELY (max_len - (p - str) < 3)) ------------------ | | 1025| 366|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 366| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 366|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 366| int _g_boolean_var_; \ | | | | 1018| 366| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 7, False: 359] | | | | ------------------ | | | | 1019| 366| _g_boolean_var_ = 1; \ | | | | 1020| 366| else \ | | | | 1021| 366| _g_boolean_var_ = 0; \ | | | | 1022| 366| _g_boolean_var_; \ | | | | 1023| 366|}) | | ------------------ | | | Branch (1025:26): [True: 7, False: 359] | | ------------------ ------------------ 1594| 7| goto error; 1595| | 1596| 359| switch (*(guchar *)p++ & 0x0f) 1597| 359| { 1598| 75| case 0: ------------------ | Branch (1598:7): [True: 75, False: 284] ------------------ 1599| 75| VALIDATE_BYTE(0xe0, 0xa0); /* 0xa0 ... 0xbf */ ------------------ | | 1485| 75| G_STMT_START { \ | | ------------------ | | | | 874| 75|#define G_STMT_START do | | ------------------ | | 1486| 75| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 75|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 75| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 75|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 75| int _g_boolean_var_; \ | | | | | | 1018| 75| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5, False: 70] | | | | | | ------------------ | | | | | | 1019| 75| _g_boolean_var_ = 1; \ | | | | | | 1020| 75| else \ | | | | | | 1021| 75| _g_boolean_var_ = 0; \ | | | | | | 1022| 75| _g_boolean_var_; \ | | | | | | 1023| 75|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 5, False: 70] | | | | ------------------ | | ------------------ | | 1487| 75| goto error; \ | | 1488| 75| } G_STMT_END | | ------------------ | | | | 882| 75|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 70] | | | | ------------------ | | ------------------ ------------------ 1600| 70| break; 1601| 74| case 0x0d: ------------------ | Branch (1601:7): [True: 74, False: 285] ------------------ 1602| 74| VALIDATE_BYTE(0xe0, 0x80); /* 0x80 ... 0x9f */ ------------------ | | 1485| 74| G_STMT_START { \ | | ------------------ | | | | 874| 74|#define G_STMT_START do | | ------------------ | | 1486| 74| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 74|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 74| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 74|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 74| int _g_boolean_var_; \ | | | | | | 1018| 74| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5, False: 69] | | | | | | ------------------ | | | | | | 1019| 74| _g_boolean_var_ = 1; \ | | | | | | 1020| 74| else \ | | | | | | 1021| 74| _g_boolean_var_ = 0; \ | | | | | | 1022| 74| _g_boolean_var_; \ | | | | | | 1023| 74|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 5, False: 69] | | | | ------------------ | | ------------------ | | 1487| 74| goto error; \ | | 1488| 74| } G_STMT_END | | ------------------ | | | | 882| 74|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 69] | | | | ------------------ | | ------------------ ------------------ 1603| 69| break; 1604| 210| default: ------------------ | Branch (1604:7): [True: 210, False: 149] ------------------ 1605| 210| VALIDATE_BYTE(0xc0, 0x80); /* 10xxxxxx */ ------------------ | | 1485| 210| G_STMT_START { \ | | ------------------ | | | | 874| 210|#define G_STMT_START do | | ------------------ | | 1486| 210| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 210|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 210| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 210|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 210| int _g_boolean_var_; \ | | | | | | 1018| 210| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 6, False: 204] | | | | | | ------------------ | | | | | | 1019| 210| _g_boolean_var_ = 1; \ | | | | | | 1020| 210| else \ | | | | | | 1021| 210| _g_boolean_var_ = 0; \ | | | | | | 1022| 210| _g_boolean_var_; \ | | | | | | 1023| 210|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 6, False: 204] | | | | ------------------ | | ------------------ | | 1487| 210| goto error; \ | | 1488| 210| } G_STMT_END | | ------------------ | | | | 882| 210|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 204] | | | | ------------------ | | ------------------ ------------------ 1606| 359| } 1607| 359| } 1608| 966| else if (*(guchar *)p < 0xf5) /* 11110xxx excluding out-of-range */ ------------------ | Branch (1608:17): [True: 959, False: 7] ------------------ 1609| 959| { 1610| 959| if (G_UNLIKELY (max_len - (p - str) < 4)) ------------------ | | 1025| 959|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 959| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 959|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 959| int _g_boolean_var_; \ | | | | 1018| 959| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 6, False: 953] | | | | ------------------ | | | | 1019| 959| _g_boolean_var_ = 1; \ | | | | 1020| 959| else \ | | | | 1021| 959| _g_boolean_var_ = 0; \ | | | | 1022| 959| _g_boolean_var_; \ | | | | 1023| 959|}) | | ------------------ | | | Branch (1025:26): [True: 6, False: 953] | | ------------------ ------------------ 1611| 6| goto error; 1612| | 1613| 953| switch (*(guchar *)p++ & 0x07) 1614| 953| { 1615| 549| case 0: ------------------ | Branch (1615:7): [True: 549, False: 404] ------------------ 1616| 549| VALIDATE_BYTE(0xc0, 0x80); /* 10xxxxxx */ ------------------ | | 1485| 549| G_STMT_START { \ | | ------------------ | | | | 874| 549|#define G_STMT_START do | | ------------------ | | 1486| 549| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 549|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 549| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 549|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 549| int _g_boolean_var_; \ | | | | | | 1018| 549| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 6, False: 543] | | | | | | ------------------ | | | | | | 1019| 549| _g_boolean_var_ = 1; \ | | | | | | 1020| 549| else \ | | | | | | 1021| 549| _g_boolean_var_ = 0; \ | | | | | | 1022| 549| _g_boolean_var_; \ | | | | | | 1023| 549|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 6, False: 543] | | | | ------------------ | | ------------------ | | 1487| 549| goto error; \ | | 1488| 549| } G_STMT_END | | ------------------ | | | | 882| 549|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 543] | | | | ------------------ | | ------------------ ------------------ 1617| 543| if (G_UNLIKELY((*(guchar *)p & 0x30) == 0)) ------------------ | | 1025| 543|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 543| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 543|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 543| int _g_boolean_var_; \ | | | | 1018| 543| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 1, False: 542] | | | | ------------------ | | | | 1019| 543| _g_boolean_var_ = 1; \ | | | | 1020| 543| else \ | | | | 1021| 543| _g_boolean_var_ = 0; \ | | | | 1022| 543| _g_boolean_var_; \ | | | | 1023| 543|}) | | ------------------ | | | Branch (1025:26): [True: 1, False: 542] | | ------------------ ------------------ 1618| 1| goto error; 1619| 542| break; 1620| 542| case 4: ------------------ | Branch (1620:7): [True: 83, False: 870] ------------------ 1621| 83| VALIDATE_BYTE(0xf0, 0x80); /* 0x80 ... 0x8f */ ------------------ | | 1485| 83| G_STMT_START { \ | | ------------------ | | | | 874| 83|#define G_STMT_START do | | ------------------ | | 1486| 83| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 83|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 83| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 83|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 83| int _g_boolean_var_; \ | | | | | | 1018| 83| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 10, False: 73] | | | | | | ------------------ | | | | | | 1019| 83| _g_boolean_var_ = 1; \ | | | | | | 1020| 83| else \ | | | | | | 1021| 83| _g_boolean_var_ = 0; \ | | | | | | 1022| 83| _g_boolean_var_; \ | | | | | | 1023| 83|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 10, False: 73] | | | | ------------------ | | ------------------ | | 1487| 83| goto error; \ | | 1488| 83| } G_STMT_END | | ------------------ | | | | 882| 83|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 73] | | | | ------------------ | | ------------------ ------------------ 1622| 73| break; 1623| 321| default: ------------------ | Branch (1623:7): [True: 321, False: 632] ------------------ 1624| 321| VALIDATE_BYTE(0xc0, 0x80); /* 10xxxxxx */ ------------------ | | 1485| 321| G_STMT_START { \ | | ------------------ | | | | 874| 321|#define G_STMT_START do | | ------------------ | | 1486| 321| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 321|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 321| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 321|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 321| int _g_boolean_var_; \ | | | | | | 1018| 321| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5, False: 316] | | | | | | ------------------ | | | | | | 1019| 321| _g_boolean_var_ = 1; \ | | | | | | 1020| 321| else \ | | | | | | 1021| 321| _g_boolean_var_ = 0; \ | | | | | | 1022| 321| _g_boolean_var_; \ | | | | | | 1023| 321|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 5, False: 316] | | | | ------------------ | | ------------------ | | 1487| 321| goto error; \ | | 1488| 321| } G_STMT_END | | ------------------ | | | | 882| 321|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 316] | | | | ------------------ | | ------------------ ------------------ 1625| 953| } 1626| 931| p++; 1627| 931| VALIDATE_BYTE(0xc0, 0x80); /* 10xxxxxx */ ------------------ | | 1485| 931| G_STMT_START { \ | | ------------------ | | | | 874| 931|#define G_STMT_START do | | ------------------ | | 1486| 931| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 931|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 931| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 931|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 931| int _g_boolean_var_; \ | | | | | | 1018| 931| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 18, False: 913] | | | | | | ------------------ | | | | | | 1019| 931| _g_boolean_var_ = 1; \ | | | | | | 1020| 931| else \ | | | | | | 1021| 931| _g_boolean_var_ = 0; \ | | | | | | 1022| 931| _g_boolean_var_; \ | | | | | | 1023| 931|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 18, False: 913] | | | | ------------------ | | ------------------ | | 1487| 931| goto error; \ | | 1488| 931| } G_STMT_END | | ------------------ | | | | 882| 931|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 913] | | | | ------------------ | | ------------------ ------------------ 1628| 931| } 1629| 7| else 1630| 7| goto error; 1631| 1.33k| } 1632| | 1633| 1.70k| p++; 1634| 1.70k| VALIDATE_BYTE(0xc0, 0x80); /* 10xxxxxx */ ------------------ | | 1485| 1.70k| G_STMT_START { \ | | ------------------ | | | | 874| 1.70k|#define G_STMT_START do | | ------------------ | | 1486| 1.70k| if (G_UNLIKELY((*(guchar *)p & (mask)) != (expect))) \ | | ------------------ | | | | 1025| 1.70k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | | | ------------------ | | | | | | 1016| 1.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1.70k| int _g_boolean_var_; \ | | | | | | 1018| 1.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 39, False: 1.66k] | | | | | | ------------------ | | | | | | 1019| 1.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 1.70k| else \ | | | | | | 1021| 1.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 1.70k| _g_boolean_var_; \ | | | | | | 1023| 1.70k|}) | | | | ------------------ | | | | | Branch (1025:26): [True: 39, False: 1.66k] | | | | ------------------ | | ------------------ | | 1487| 1.70k| goto error; \ | | 1488| 1.70k| } G_STMT_END | | ------------------ | | | | 882| 1.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1.66k] | | | | ------------------ | | ------------------ ------------------ 1635| | 1636| 1.66k| continue; 1637| | 1638| 1.66k| error: 1639| 147| return last; 1640| 1.70k| } 1641| 57.1k| } 1642| | 1643| 2.58k| return p; 1644| 2.73k|} gsignal.c:g_bit_storage_impl: 413| 4|{ 414| 4|#if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__OPTIMIZE__) 415| 4| return G_LIKELY (number) ? ------------------ | | 1024| 4|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 4| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 4|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 4| int _g_boolean_var_; \ | | | | 1018| 4| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 4, False: 0] | | | | ------------------ | | | | 1019| 4| _g_boolean_var_ = 1; \ | | | | 1020| 4| else \ | | | | 1021| 4| _g_boolean_var_ = 0; \ | | | | 1022| 4| _g_boolean_var_; \ | | | | 1023| 4|}) | | ------------------ | | | Branch (1024:24): [True: 4, False: 0] | | ------------------ ------------------ 416| 4| ((GLIB_SIZEOF_LONG * 8U - 1) ^ (guint) __builtin_clzl(number)) + 1 : 1; ------------------ | | 73| 4|#define GLIB_SIZEOF_LONG 8 ------------------ 417| |#else 418| | guint n_bits = 0; 419| | 420| | do 421| | { 422| | n_bits++; 423| | number >>= 1; 424| | } 425| | while (number); 426| | return n_bits; 427| |#endif 428| 4|} gvalue.c:g_bit_storage_impl: 413| 682|{ 414| 682|#if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__OPTIMIZE__) 415| 682| return G_LIKELY (number) ? ------------------ | | 1024| 682|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 682| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 682|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 682| int _g_boolean_var_; \ | | | | 1018| 682| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 682, False: 0] | | | | ------------------ | | | | 1019| 682| _g_boolean_var_ = 1; \ | | | | 1020| 682| else \ | | | | 1021| 682| _g_boolean_var_ = 0; \ | | | | 1022| 682| _g_boolean_var_; \ | | | | 1023| 682|}) | | ------------------ | | | Branch (1024:24): [True: 682, False: 0] | | ------------------ ------------------ 416| 682| ((GLIB_SIZEOF_LONG * 8U - 1) ^ (guint) __builtin_clzl(number)) + 1 : 1; ------------------ | | 73| 682|#define GLIB_SIZEOF_LONG 8 ------------------ 417| |#else 418| | guint n_bits = 0; 419| | 420| | do 421| | { 422| | n_bits++; 423| | number >>= 1; 424| | } 425| | while (number); 426| | return n_bits; 427| |#endif 428| 682|} gmessages.c:g_bit_nth_msf_impl: 399| 514k|{ 400| 514k| if (nth_bit < 0 || G_UNLIKELY (nth_bit > GLIB_SIZEOF_LONG * 8)) ------------------ | | 1025| 257k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 257k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 257k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 257k| int _g_boolean_var_; \ | | | | 1018| 257k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 257k] | | | | ------------------ | | | | 1019| 257k| _g_boolean_var_ = 1; \ | | | | 1020| 257k| else \ | | | | 1021| 257k| _g_boolean_var_ = 0; \ | | | | 1022| 257k| _g_boolean_var_; \ | | | | 1023| 257k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 257k] | | ------------------ ------------------ | Branch (400:7): [True: 257k, False: 257k] ------------------ 401| 257k| nth_bit = GLIB_SIZEOF_LONG * 8; ------------------ | | 73| 257k|#define GLIB_SIZEOF_LONG 8 ------------------ 402| 16.7M| while (nth_bit > 0) ------------------ | Branch (402:10): [True: 16.4M, False: 257k] ------------------ 403| 16.4M| { 404| 16.4M| nth_bit--; 405| 16.4M| if (mask & (1UL << nth_bit)) ------------------ | Branch (405:11): [True: 257k, False: 16.1M] ------------------ 406| 257k| return nth_bit; 407| 16.4M| } 408| 257k| return -1; 409| 514k|} gslice.c:g_bit_storage_impl: 413| 92|{ 414| 92|#if defined(__GNUC__) && (__GNUC__ >= 4) && defined(__OPTIMIZE__) 415| 92| return G_LIKELY (number) ? ------------------ | | 1024| 92|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 92| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 92|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 92| int _g_boolean_var_; \ | | | | 1018| 92| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 92, False: 0] | | | | ------------------ | | | | 1019| 92| _g_boolean_var_ = 1; \ | | | | 1020| 92| else \ | | | | 1021| 92| _g_boolean_var_ = 0; \ | | | | 1022| 92| _g_boolean_var_; \ | | | | 1023| 92|}) | | ------------------ | | | Branch (1024:24): [True: 92, False: 0] | | ------------------ ------------------ 416| 92| ((GLIB_SIZEOF_LONG * 8U - 1) ^ (guint) __builtin_clzl(number)) + 1 : 1; ------------------ | | 73| 92|#define GLIB_SIZEOF_LONG 8 ------------------ 417| |#else 418| | guint n_bits = 0; 419| | 420| | do 421| | { 422| | n_bits++; 423| | number >>= 1; 424| | } 425| | while (number); 426| | return n_bits; 427| |#endif 428| 92|} _g_atomic_array_init: 102| 40|{ 103| | array->data = NULL; 104| 40|} _g_atomic_array_copy: 126| 60|{ 127| 60| guint8 *new, *old; 128| 60| gsize old_size, new_size; 129| | 130| 60| G_LOCK (array); ------------------ | | 135| 60|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 60|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 131| 60| old = g_atomic_pointer_get (&array->data); ------------------ | | 113| 60| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 60|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 114| 60| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 60|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 115| 60| glib_typeof (*(atomic)) gapg_temp_newval; \ | | ------------------ | | | | 238| 60|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 116| 60| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 60|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 117| 60| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | 118| 60| gapg_temp_newval; \ | | 119| 60| })) ------------------ 132| 60| if (old) ------------------ | Branch (132:7): [True: 2, False: 58] ------------------ 133| 2| { 134| 2| old_size = G_ATOMIC_ARRAY_DATA_SIZE (old); ------------------ | | 28| 2|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) ------------------ 135| 2| new_size = old_size + additional_element_size; 136| | /* Don't reuse if copying to same size, as this may end 137| | up reusing the same pointer for the same array thus 138| | confusing the transaction check */ 139| 2| new = freelist_alloc (new_size, additional_element_size != 0); 140| 2| memcpy (new, old, old_size); 141| 2| } 142| 58| else if (additional_element_size != 0) ------------------ | Branch (142:12): [True: 5, False: 53] ------------------ 143| 5| { 144| 5| new_size = header_size + additional_element_size; 145| 5| new = freelist_alloc (new_size, TRUE); ------------------ | | 818| 5|#define TRUE (!FALSE) | | ------------------ | | | | 814| 5|#define FALSE (0) | | ------------------ ------------------ 146| 5| } 147| 53| else 148| 53| new = NULL; 149| 60| G_UNLOCK (array); ------------------ | | 136| 60|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 60|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 150| 60| return new; 151| 60|} _g_atomic_array_update: 160| 7|{ 161| 7| guint8 *old; 162| | 163| 7| G_LOCK (array); ------------------ | | 135| 7|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 7|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 164| 7| old = g_atomic_pointer_get (&array->data); ------------------ | | 113| 7| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 114| 7| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 7|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 115| 7| glib_typeof (*(atomic)) gapg_temp_newval; \ | | ------------------ | | | | 238| 7|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 116| 7| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 7|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 117| 7| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | 118| 7| gapg_temp_newval; \ | | 119| 7| })) ------------------ 165| | 166| 7| g_assert (old == NULL || G_ATOMIC_ARRAY_DATA_SIZE (old) <= G_ATOMIC_ARRAY_DATA_SIZE (new_data)); ------------------ | | 231| 7|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 7|#define G_STMT_START do | | ------------------ | | 232| 7| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 7|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7| int _g_boolean_var_; \ | | | | | | 1018| 15| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 6, False: 1] | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 7| _g_boolean_var_ = 1; \ | | | | | | 1020| 7| else \ | | | | | | 1021| 7| _g_boolean_var_ = 0; \ | | | | | | 1022| 7| _g_boolean_var_; \ | | | | | | 1023| 7|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 233| 7| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 7| } G_STMT_END | | ------------------ | | | | 882| 7|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7] | | | | ------------------ | | ------------------ ------------------ 167| | 168| 7| g_atomic_pointer_set (&array->data, new_data); ------------------ | | 121| 7| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 122| 7| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 7|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 123| 7| glib_typeof ((atomic)) gaps_temp_atomic = (atomic); \ | | ------------------ | | | | 238| 7|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 124| 7| glib_typeof (*(atomic)) gaps_temp_newval = (newval); \ | | ------------------ | | | | 238| 7|#define glib_typeof(t) __typeof__ (t) | | ------------------ | | 125| 7| (void) (0 ? (gpointer) * (atomic) : NULL); \ | | ------------------ | | | Branch (125:13): [Folded, False: 7] | | ------------------ | | 126| 7| __atomic_store (gaps_temp_atomic, &gaps_temp_newval, __ATOMIC_SEQ_CST); \ | | 127| 7| })) ------------------ 169| 7| if (old) ------------------ | Branch (169:7): [True: 1, False: 6] ------------------ 170| 1| freelist_free (old); 171| 7| G_UNLOCK (array); ------------------ | | 136| 7|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 7|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 172| 7|} gatomicarray.c:freelist_alloc: 60| 7|{ 61| 7| gpointer mem; 62| 7| FreeListNode *free, **prev; 63| 7| gsize real_size; 64| | 65| 7| if (reuse) ------------------ | Branch (65:7): [True: 6, False: 1] ------------------ 66| 6| { 67| 6| for (free = freelist, prev = &freelist; free != NULL; prev = &free->next, free = free->next) ------------------ | Branch (67:47): [True: 0, False: 6] ------------------ 68| 0| { 69| 0| if (G_ATOMIC_ARRAY_DATA_SIZE (free) == size) ------------------ | | 28| 0|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) ------------------ | Branch (69:8): [True: 0, False: 0] ------------------ 70| 0| { 71| 0| *prev = free->next; 72| 0| return (gpointer)free; 73| 0| } 74| 0| } 75| 6| } 76| | 77| 7| real_size = sizeof (gsize) + MAX (size, sizeof (FreeListNode)); ------------------ | | 822| 7|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 4, False: 3] | | ------------------ ------------------ 78| 7| mem = g_slice_alloc (real_size); 79| 7| mem = ((char *) mem) + sizeof (gsize); 80| 7| G_ATOMIC_ARRAY_DATA_SIZE (mem) = size; ------------------ | | 28| 7|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) ------------------ 81| | 82| 7|#if ENABLE_VALGRIND 83| 7| VALGRIND_MALLOCLIKE_BLOCK (mem, real_size - sizeof (gsize), FALSE, FALSE); ------------------ | | 6479| 7| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \ | | ------------------ | | | | 203| 7| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 7| __extension__ \ | | | | | | 414| 7| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 7| volatile unsigned long int _zzq_result; \ | | | | | | 416| 7| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 7| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 7| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 7| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 7| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 7| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 7| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 7| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 7| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 7| : "=d" (_zzq_result) \ | | | | | | 426| 7| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 7| : "cc", "memory" \ | | | | | | 428| 7| ); \ | | | | | | 429| 7| _zzq_result; \ | | | | | | 430| 7| }) | | | | ------------------ | | | | 204| 7| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 7| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 7] | | | | ------------------ | | ------------------ | | 6480| 7| addr, sizeB, rzB, is_zeroed, 0) ------------------ 84| 7|#endif 85| | 86| 7| return mem; 87| 7|} gatomicarray.c:freelist_free: 92| 1|{ 93| 1| FreeListNode *free; 94| | 95| 1| free = mem; 96| 1| free->next = freelist; 97| 1| freelist = free; 98| 1|} _g_boxed_type_init: 102| 2|{ 103| 2| const GTypeInfo info = { 104| 2| 0, /* class_size */ 105| 2| NULL, /* base_init */ 106| 2| NULL, /* base_destroy */ 107| 2| NULL, /* class_init */ 108| 2| NULL, /* class_destroy */ 109| 2| NULL, /* class_data */ 110| 2| 0, /* instance_size */ 111| 2| 0, /* n_preallocs */ 112| 2| NULL, /* instance_init */ 113| 2| NULL, /* value_table */ 114| 2| }; 115| 2| const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, }; 116| 2| GType type G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */; 117| | 118| | /* G_TYPE_BOXED 119| | */ 120| 2| type = g_type_register_fundamental (G_TYPE_BOXED, g_intern_static_string ("GBoxed"), &info, &finfo, ------------------ | | 166| 2|#define G_TYPE_BOXED G_TYPE_MAKE_FUNDAMENTAL (18) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 121| 2| G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT); 122| 2| g_assert (type == G_TYPE_BOXED); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 123| 2|} g_boxed_type_register_static: 291| 2|{ 292| 2| static const GTypeValueTable vtable = { 293| 2| boxed_proxy_value_init, 294| 2| boxed_proxy_value_free, 295| 2| boxed_proxy_value_copy, 296| 2| boxed_proxy_value_peek_pointer, 297| 2| "p", 298| 2| boxed_proxy_collect_value, 299| 2| "p", 300| 2| boxed_proxy_lcopy_value, 301| 2| }; 302| 2| GTypeInfo type_info = { 303| 2| 0, /* class_size */ 304| 2| NULL, /* base_init */ 305| 2| NULL, /* base_finalize */ 306| 2| NULL, /* class_init */ 307| 2| NULL, /* class_finalize */ 308| 2| NULL, /* class_data */ 309| 2| 0, /* instance_size */ 310| 2| 0, /* n_preallocs */ 311| 2| NULL, /* instance_init */ 312| 2| &vtable, /* value_table */ 313| 2| }; 314| 2| GType type; 315| | 316| 2| g_return_val_if_fail (name != NULL, 0); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 317| 2| g_return_val_if_fail (boxed_copy != NULL, 0); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 318| 2| g_return_val_if_fail (boxed_free != NULL, 0); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 319| 2| g_return_val_if_fail (g_type_from_name (name) == 0, 0); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 320| | 321| 2| type = g_type_register_static (G_TYPE_BOXED, name, &type_info, 0); ------------------ | | 166| 2|#define G_TYPE_BOXED G_TYPE_MAKE_FUNDAMENTAL (18) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 322| | 323| | /* install proxy functions upon successful registration */ 324| 2| if (type) ------------------ | Branch (324:7): [True: 2, False: 0] ------------------ 325| 2| _g_type_boxed_init (type, boxed_copy, boxed_free); 326| | 327| 2| return type; 328| 2|} g_closure_new_simple: 194| 1|{ 195| 1| GClosure *closure; 196| 1| gint private_size; 197| 1| gchar *allocated; 198| | 199| 1| g_return_val_if_fail (sizeof_closure >= sizeof (GClosure), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 200| | 201| 1| private_size = sizeof (GRealClosure) - sizeof (GClosure); 202| | 203| 1|#ifdef ENABLE_VALGRIND 204| | /* See comments in gtype.c about what's going on here... */ 205| 1| if (RUNNING_ON_VALGRIND) ------------------ | | 6215| 1| (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ | | ------------------ | | | | 413| 1| __extension__ \ | | | | 414| 1| ({ volatile unsigned long int _zzq_args[6]; \ | | | | 415| 1| volatile unsigned long int _zzq_result; \ | | | | 416| 1| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | 417| 1| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | 418| 1| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | 419| 1| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | 420| 1| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | 421| 1| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | 422| 1| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | 423| 1| /* %RDX = client_request ( %RAX ) */ \ | | | | 424| 1| "xchgq %%rbx,%%rbx" \ | | | | 425| 1| : "=d" (_zzq_result) \ | | | | 426| 1| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | 427| 1| : "cc", "memory" \ | | | | 428| 1| ); \ | | | | 429| 1| _zzq_result; \ | | | | 430| 1| }) | | ------------------ | | | Branch (6215:5): [True: 0, False: 1] | | ------------------ | | 6216| 1| VG_USERREQ__RUNNING_ON_VALGRIND, \ | | 6217| 1| 0, 0, 0, 0, 0) \ ------------------ 206| 0| { 207| 0| private_size += sizeof (gpointer); 208| | 209| 0| allocated = g_malloc0 (private_size + sizeof_closure + sizeof (gpointer)); 210| | 211| 0| *(gpointer *) (allocated + private_size + sizeof_closure) = allocated + sizeof (gpointer); 212| | 213| 0| VALGRIND_MALLOCLIKE_BLOCK (allocated + private_size, sizeof_closure + sizeof (gpointer), 0, TRUE); ------------------ | | 6479| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6480| 0| addr, sizeB, rzB, is_zeroed, 0) ------------------ 214| 0| VALGRIND_MALLOCLIKE_BLOCK (allocated + sizeof (gpointer), private_size - sizeof (gpointer), 0, TRUE); ------------------ | | 6479| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6480| 0| addr, sizeB, rzB, is_zeroed, 0) ------------------ 215| 0| } 216| 1| else 217| 1|#endif 218| 1| allocated = g_malloc0 (private_size + sizeof_closure); 219| | 220| 1| closure = (GClosure *) (allocated + private_size); 221| | 222| 1| SET (closure, ref_count, 1); ------------------ | | 122| 1|#define SET(_closure, _field, _value) CHANGE_FIELD (_closure, _field, =, _value, TRUE, (void), (void) ) | | ------------------ | | | | 104| 1|#define CHANGE_FIELD(_closure, _field, _OP, _value, _must_set, _SET_OLD, _SET_NEW) \ | | | | ------------------ | | | | | | 874| 1|#define G_STMT_START do | | | | ------------------ | | | | 105| 1|G_STMT_START { \ | | | | 106| 1| ClosureInt *cunion = (ClosureInt*) _closure; \ | | | | 107| 1| gint new_int, old_int, success; \ | | | | 108| 1| do \ | | | | 109| 1| { \ | | | | 110| 1| ClosureInt tmp; \ | | | | 111| 1| tmp.vint = old_int = cunion->vint; \ | | | | 112| 1| _SET_OLD tmp.closure._field; \ | | | | 113| 1| tmp.closure._field _OP _value; \ | | | | 114| 1| _SET_NEW tmp.closure._field; \ | | | | 115| 1| new_int = tmp.vint; \ | | | | 116| 1| success = g_atomic_int_compare_and_exchange (&cunion->vint, old_int, new_int); \ | | | | ------------------ | | | | | | 160| 1| (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 161| 1| gint gaicae_oldval = (oldval); \ | | | | | | 162| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | | | ------------------ | | | | | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | | | ------------------ | | | | | | 163| 1| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | | | | | ------------------ | | | | | | | Branch (163:13): [Folded, False: 1] | | | | | | ------------------ | | | | | | 164| 1| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 1|#define FALSE (0) | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 818| 1|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 1|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | | Branch (164:5): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 165| 1| })) | | | | ------------------ | | | | 117| 1| } \ | | | | 118| 1| while (!success && _must_set); \ | | | | ------------------ | | | | | Branch (118:10): [True: 0, False: 1] | | | | | Branch (118:22): [True: 0, Folded] | | | | ------------------ | | | | 119| 1|} G_STMT_END | | | | ------------------ | | | | | | 882| 1|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 223| 1| SET (closure, floating, TRUE); ------------------ | | 122| 1|#define SET(_closure, _field, _value) CHANGE_FIELD (_closure, _field, =, _value, TRUE, (void), (void) ) | | ------------------ | | | | 104| 1|#define CHANGE_FIELD(_closure, _field, _OP, _value, _must_set, _SET_OLD, _SET_NEW) \ | | | | ------------------ | | | | | | 874| 1|#define G_STMT_START do | | | | ------------------ | | | | 105| 1|G_STMT_START { \ | | | | 106| 1| ClosureInt *cunion = (ClosureInt*) _closure; \ | | | | 107| 1| gint new_int, old_int, success; \ | | | | 108| 1| do \ | | | | 109| 1| { \ | | | | 110| 1| ClosureInt tmp; \ | | | | 111| 1| tmp.vint = old_int = cunion->vint; \ | | | | 112| 1| _SET_OLD tmp.closure._field; \ | | | | 113| 1| tmp.closure._field _OP _value; \ | | | | 114| 1| _SET_NEW tmp.closure._field; \ | | | | 115| 1| new_int = tmp.vint; \ | | | | 116| 1| success = g_atomic_int_compare_and_exchange (&cunion->vint, old_int, new_int); \ | | | | ------------------ | | | | | | 160| 1| (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 161| 1| gint gaicae_oldval = (oldval); \ | | | | | | 162| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | | | ------------------ | | | | | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | | | ------------------ | | | | | | 163| 1| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | | | | | ------------------ | | | | | | | Branch (163:13): [Folded, False: 1] | | | | | | ------------------ | | | | | | 164| 1| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 1|#define FALSE (0) | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 818| 1|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 1|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | | Branch (164:5): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 165| 1| })) | | | | ------------------ | | | | 117| 1| } \ | | | | 118| 1| while (!success && _must_set); \ | | | | ------------------ | | | | | Branch (118:10): [True: 0, False: 1] | | | | | Branch (118:22): [True: 0, Folded] | | | | ------------------ | | | | 119| 1|} G_STMT_END | | | | ------------------ | | | | | | 882| 1|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 224| 1| closure->data = data; 225| | 226| 1| return closure; 227| 1|} g_closure_set_meta_marshal: 349| 1|{ 350| 1| GRealClosure *real_closure; 351| | 352| 1| g_return_if_fail (closure != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 353| 1| g_return_if_fail (meta_marshal != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 354| 1| g_return_if_fail (closure->is_invalid == FALSE); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 355| 1| g_return_if_fail (closure->in_marshal == FALSE); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 356| | 357| 1| real_closure = G_REAL_CLOSURE (closure); ------------------ | | 63| 1| ((GRealClosure *)G_STRUCT_MEMBER_P ((_c), -G_STRUCT_OFFSET (GRealClosure, closure))) | | ------------------ | | | | 860| 1| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 358| | 359| 1| g_return_if_fail (real_closure->meta_marshal == NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 360| | 361| 1| real_closure->meta_marshal = meta_marshal; 362| 1| real_closure->meta_marshal_data = marshal_data; 363| 1|} g_closure_ref: 545| 1|{ 546| 1| guint new_ref_count; 547| 1| g_return_val_if_fail (closure != NULL, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 548| 1| g_return_val_if_fail (closure->ref_count > 0, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 549| 1| g_return_val_if_fail (closure->ref_count < CLOSURE_MAX_REF_COUNT, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 550| | 551| 1| INC_ASSIGN (closure, ref_count, &new_ref_count); ------------------ | | 124| 1|#define INC_ASSIGN(_closure, _field, _newv) CHANGE_FIELD (_closure, _field, +=, 1, TRUE, (void), *(_newv) = ) | | ------------------ | | | | 104| 1|#define CHANGE_FIELD(_closure, _field, _OP, _value, _must_set, _SET_OLD, _SET_NEW) \ | | | | ------------------ | | | | | | 874| 1|#define G_STMT_START do | | | | ------------------ | | | | 105| 1|G_STMT_START { \ | | | | 106| 1| ClosureInt *cunion = (ClosureInt*) _closure; \ | | | | 107| 1| gint new_int, old_int, success; \ | | | | 108| 1| do \ | | | | 109| 1| { \ | | | | 110| 1| ClosureInt tmp; \ | | | | 111| 1| tmp.vint = old_int = cunion->vint; \ | | | | 112| 1| _SET_OLD tmp.closure._field; \ | | | | 113| 1| tmp.closure._field _OP _value; \ | | | | 114| 1| _SET_NEW tmp.closure._field; \ | | | | 115| 1| new_int = tmp.vint; \ | | | | 116| 1| success = g_atomic_int_compare_and_exchange (&cunion->vint, old_int, new_int); \ | | | | ------------------ | | | | | | 160| 1| (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 161| 1| gint gaicae_oldval = (oldval); \ | | | | | | 162| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | | | ------------------ | | | | | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | | | ------------------ | | | | | | 163| 1| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | | | | | ------------------ | | | | | | | Branch (163:13): [Folded, False: 1] | | | | | | ------------------ | | | | | | 164| 1| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 1|#define FALSE (0) | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 818| 1|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 1|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | | Branch (164:5): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 165| 1| })) | | | | ------------------ | | | | 117| 1| } \ | | | | 118| 1| while (!success && _must_set); \ | | | | ------------------ | | | | | Branch (118:10): [True: 0, False: 1] | | | | | Branch (118:22): [True: 0, Folded] | | | | ------------------ | | | | 119| 1|} G_STMT_END | | | | ------------------ | | | | | | 882| 1|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 552| 1| g_return_val_if_fail (new_ref_count > 1, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 553| | 554| 1| return closure; 555| 1|} g_closure_unref: 602| 1|{ 603| 1| guint new_ref_count; 604| | 605| 1| g_return_if_fail (closure != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 606| 1| g_return_if_fail (closure->ref_count > 0); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 607| | 608| 1| if (closure->ref_count == 1) /* last unref, invalidate first */ ------------------ | Branch (608:7): [True: 0, False: 1] ------------------ 609| 0| g_closure_invalidate (closure); 610| | 611| 1| DEC_ASSIGN (closure, ref_count, &new_ref_count); ------------------ | | 126| 1|#define DEC_ASSIGN(_closure, _field, _newv) CHANGE_FIELD (_closure, _field, -=, 1, TRUE, (void), *(_newv) = ) | | ------------------ | | | | 104| 1|#define CHANGE_FIELD(_closure, _field, _OP, _value, _must_set, _SET_OLD, _SET_NEW) \ | | | | ------------------ | | | | | | 874| 1|#define G_STMT_START do | | | | ------------------ | | | | 105| 1|G_STMT_START { \ | | | | 106| 1| ClosureInt *cunion = (ClosureInt*) _closure; \ | | | | 107| 1| gint new_int, old_int, success; \ | | | | 108| 1| do \ | | | | 109| 1| { \ | | | | 110| 1| ClosureInt tmp; \ | | | | 111| 1| tmp.vint = old_int = cunion->vint; \ | | | | 112| 1| _SET_OLD tmp.closure._field; \ | | | | 113| 1| tmp.closure._field _OP _value; \ | | | | 114| 1| _SET_NEW tmp.closure._field; \ | | | | 115| 1| new_int = tmp.vint; \ | | | | 116| 1| success = g_atomic_int_compare_and_exchange (&cunion->vint, old_int, new_int); \ | | | | ------------------ | | | | | | 160| 1| (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 161| 1| gint gaicae_oldval = (oldval); \ | | | | | | 162| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | | | ------------------ | | | | | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | | | ------------------ | | | | | | 163| 1| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | | | | | ------------------ | | | | | | | Branch (163:13): [Folded, False: 1] | | | | | | ------------------ | | | | | | 164| 1| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 1|#define FALSE (0) | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 818| 1|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 1|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | | Branch (164:5): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 165| 1| })) | | | | ------------------ | | | | 117| 1| } \ | | | | 118| 1| while (!success && _must_set); \ | | | | ------------------ | | | | | Branch (118:10): [True: 0, False: 1] | | | | | Branch (118:22): [True: 0, Folded] | | | | ------------------ | | | | 119| 1|} G_STMT_END | | | | ------------------ | | | | | | 882| 1|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 612| | 613| 1| if (new_ref_count == 0) ------------------ | Branch (613:7): [True: 0, False: 1] ------------------ 614| 0| { 615| 0| closure_invoke_notifiers (closure, FNOTIFY); 616| 0| g_free (closure->notifiers); 617| | 618| 0|#ifdef ENABLE_VALGRIND 619| | /* See comments in gtype.c about what's going on here... */ 620| 0| if (RUNNING_ON_VALGRIND) ------------------ | | 6215| 0| (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ | | ------------------ | | | | 413| 0| __extension__ \ | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | 425| 0| : "=d" (_zzq_result) \ | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | 427| 0| : "cc", "memory" \ | | | | 428| 0| ); \ | | | | 429| 0| _zzq_result; \ | | | | 430| 0| }) | | ------------------ | | | Branch (6215:5): [True: 0, False: 0] | | ------------------ | | 6216| 0| VG_USERREQ__RUNNING_ON_VALGRIND, \ | | 6217| 0| 0, 0, 0, 0, 0) \ ------------------ 621| 0| { 622| 0| gchar *allocated; 623| | 624| 0| allocated = (gchar *) G_REAL_CLOSURE (closure); ------------------ | | 63| 0| ((GRealClosure *)G_STRUCT_MEMBER_P ((_c), -G_STRUCT_OFFSET (GRealClosure, closure))) | | ------------------ | | | | 860| 0| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 625| 0| allocated -= sizeof (gpointer); 626| | 627| 0| g_free (allocated); 628| | 629| 0| VALGRIND_FREELIKE_BLOCK (allocated + sizeof (gpointer), 0); ------------------ | | 6493| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__FREELIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6494| 0| addr, rzB, 0, 0, 0) ------------------ 630| 0| VALGRIND_FREELIKE_BLOCK (closure, 0); ------------------ | | 6493| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__FREELIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6494| 0| addr, rzB, 0, 0, 0) ------------------ 631| 0| } 632| 0| else 633| 0|#endif 634| 0| g_free (G_REAL_CLOSURE (closure)); ------------------ | | 63| 0| ((GRealClosure *)G_STRUCT_MEMBER_P ((_c), -G_STRUCT_OFFSET (GRealClosure, closure))) | | ------------------ | | | | 860| 0| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 635| 0| } 636| 1|} g_closure_sink: 686| 1|{ 687| 1| g_return_if_fail (closure != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 688| 1| g_return_if_fail (closure->ref_count > 0); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 689| | 690| | /* floating is basically a kludge to avoid creating closures 691| | * with a ref_count of 0. so the initial ref_count a closure has 692| | * is unowned. with invoking g_closure_sink() code may 693| | * indicate that it takes over that initial ref_count. 694| | */ 695| 1| if (closure->floating) ------------------ | Branch (695:7): [True: 1, False: 0] ------------------ 696| 1| { 697| 1| gboolean was_floating; 698| 1| SWAP (closure, floating, FALSE, &was_floating); ------------------ | | 121| 1|#define SWAP(_closure, _field, _value, _oldv) CHANGE_FIELD (_closure, _field, =, _value, TRUE, *(_oldv) =, (void) ) | | ------------------ | | | | 104| 1|#define CHANGE_FIELD(_closure, _field, _OP, _value, _must_set, _SET_OLD, _SET_NEW) \ | | | | ------------------ | | | | | | 874| 1|#define G_STMT_START do | | | | ------------------ | | | | 105| 1|G_STMT_START { \ | | | | 106| 1| ClosureInt *cunion = (ClosureInt*) _closure; \ | | | | 107| 1| gint new_int, old_int, success; \ | | | | 108| 1| do \ | | | | 109| 1| { \ | | | | 110| 1| ClosureInt tmp; \ | | | | 111| 1| tmp.vint = old_int = cunion->vint; \ | | | | 112| 1| _SET_OLD tmp.closure._field; \ | | | | 113| 1| tmp.closure._field _OP _value; \ | | | | 114| 1| _SET_NEW tmp.closure._field; \ | | | | 115| 1| new_int = tmp.vint; \ | | | | 116| 1| success = g_atomic_int_compare_and_exchange (&cunion->vint, old_int, new_int); \ | | | | ------------------ | | | | | | 160| 1| (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 161| 1| gint gaicae_oldval = (oldval); \ | | | | | | 162| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | | | ------------------ | | | | | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | | | ------------------ | | | | | | 163| 1| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | | | | | ------------------ | | | | | | | Branch (163:13): [Folded, False: 1] | | | | | | ------------------ | | | | | | 164| 1| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 1|#define FALSE (0) | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 818| 1|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 1|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | | Branch (164:5): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 165| 1| })) | | | | ------------------ | | | | 117| 1| } \ | | | | 118| 1| while (!success && _must_set); \ | | | | ------------------ | | | | | Branch (118:10): [True: 0, False: 1] | | | | | Branch (118:22): [True: 0, Folded] | | | | ------------------ | | | | 119| 1|} G_STMT_END | | | | ------------------ | | | | | | 882| 1|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 699| | /* unref floating flag only once */ 700| 1| if (was_floating) ------------------ | Branch (700:11): [True: 1, False: 0] ------------------ 701| 1| g_closure_unref (closure); 702| 1| } 703| 1|} g_closure_set_marshal: 901| 1|{ 902| 1| g_return_if_fail (closure != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 903| 1| g_return_if_fail (marshal != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 904| | 905| 1| if (closure->marshal && closure->marshal != marshal) ------------------ | Branch (905:7): [True: 0, False: 1] | Branch (905:27): [True: 0, False: 0] ------------------ 906| 0| g_warning ("attempt to override closure->marshal (%p) with new marshal (%p)", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 907| 1| closure->marshal, marshal); 908| 1| else 909| 1| closure->marshal = marshal; 910| 1|} _g_closure_set_va_marshal: 915| 1|{ 916| 1| GRealClosure *real_closure; 917| | 918| 1| g_return_if_fail (closure != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 919| 1| g_return_if_fail (marshal != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 920| | 921| 1| real_closure = G_REAL_CLOSURE (closure); ------------------ | | 63| 1| ((GRealClosure *)G_STRUCT_MEMBER_P ((_c), -G_STRUCT_OFFSET (GRealClosure, closure))) | | ------------------ | | | | 860| 1| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 922| | 923| 1| if (real_closure->va_marshal && real_closure->va_marshal != marshal) ------------------ | Branch (923:7): [True: 0, False: 1] | Branch (923:35): [True: 0, False: 0] ------------------ 924| 0| g_warning ("attempt to override closure->va_marshal (%p) with new marshal (%p)", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 925| 1| real_closure->va_marshal, marshal); 926| 1| else 927| 1| real_closure->va_marshal = marshal; 928| 1|} _g_closure_is_void: 1068| 3.85k|{ 1069| 3.85k| GRealClosure *real_closure; 1070| 3.85k| GTypeClass *class; 1071| 3.85k| gpointer callback; 1072| 3.85k| GType itype; 1073| 3.85k| guint offset; 1074| | 1075| 3.85k| if (closure->is_invalid) ------------------ | Branch (1075:7): [True: 0, False: 3.85k] ------------------ 1076| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 1077| | 1078| 3.85k| real_closure = G_REAL_CLOSURE (closure); ------------------ | | 63| 3.85k| ((GRealClosure *)G_STRUCT_MEMBER_P ((_c), -G_STRUCT_OFFSET (GRealClosure, closure))) | | ------------------ | | | | 860| 3.85k| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 1079| | 1080| 3.85k| if (real_closure->meta_marshal == g_type_iface_meta_marshal) ------------------ | Branch (1080:7): [True: 0, False: 3.85k] ------------------ 1081| 0| { 1082| 0| itype = (GType) closure->data; 1083| 0| offset = GPOINTER_TO_UINT (real_closure->meta_marshal_data); ------------------ | | 99| 0|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 1084| | 1085| 0| class = G_TYPE_INSTANCE_GET_INTERFACE (instance, itype, GTypeClass); ------------------ | | 540| 0|#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type)) | | ------------------ | | | | 2310| 0|#define _G_TYPE_IGI(ip, gt, ct) ((ct*) g_type_interface_peek (((GTypeInstance*) ip)->g_class, gt)) | | ------------------ ------------------ 1086| 0| callback = G_STRUCT_MEMBER (gpointer, class, offset); ------------------ | | 862| 0| (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset))) | | ------------------ | | | | 860| 0| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 1087| 0| return callback == NULL; 1088| 0| } 1089| 3.85k| else if (real_closure->meta_marshal == g_type_class_meta_marshal) ------------------ | Branch (1089:12): [True: 3.85k, False: 0] ------------------ 1090| 3.85k| { 1091| 3.85k| offset = GPOINTER_TO_UINT (real_closure->meta_marshal_data); ------------------ | | 99| 3.85k|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 1092| | 1093| 3.85k| class = G_TYPE_INSTANCE_GET_CLASS (instance, itype, GTypeClass); ------------------ | | 527| 3.85k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | ------------------ | | | | 2309| 3.85k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | ------------------ ------------------ 1094| 3.85k| callback = G_STRUCT_MEMBER (gpointer, class, offset); ------------------ | | 862| 3.85k| (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset))) | | ------------------ | | | | 860| 3.85k| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 1095| 3.85k| return callback == NULL; 1096| 3.85k| } 1097| | 1098| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1099| 3.85k|} g_signal_type_cclosure_new: 1144| 1|{ 1145| 1| GClosure *closure; 1146| | 1147| 1| g_return_val_if_fail (G_TYPE_IS_CLASSED (itype) || G_TYPE_IS_INTERFACE (itype), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1148| 1| g_return_val_if_fail (struct_offset >= sizeof (GTypeClass), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1149| | 1150| 1| closure = g_closure_new_simple (sizeof (GClosure), (gpointer) itype); 1151| 1| if (G_TYPE_IS_INTERFACE (itype)) ------------------ | | 293| 1|#define G_TYPE_IS_INTERFACE(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE) | | ------------------ | | | | 38| 1|#define G_TYPE_FUNDAMENTAL(type) (g_type_fundamental (type)) | | ------------------ | | #define G_TYPE_IS_INTERFACE(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 1|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (293:49): [True: 0, False: 1] | | ------------------ ------------------ 1152| 0| { 1153| 0| g_closure_set_meta_marshal (closure, GUINT_TO_POINTER (struct_offset), g_type_iface_meta_marshal); ------------------ | | 102| 0|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 1154| 0| g_closure_set_meta_va_marshal (closure, g_type_iface_meta_marshalv); 1155| 0| } 1156| 1| else 1157| 1| { 1158| 1| g_closure_set_meta_marshal (closure, GUINT_TO_POINTER (struct_offset), g_type_class_meta_marshal); ------------------ | | 102| 1|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 1159| 1| g_closure_set_meta_va_marshal (closure, g_type_class_meta_marshalv); 1160| 1| } 1161| 1| return closure; 1162| 1|} gclosure.c:g_closure_set_meta_va_marshal: 308| 1|{ 309| 1| GRealClosure *real_closure; 310| | 311| 1| g_return_if_fail (closure != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 312| 1| g_return_if_fail (va_meta_marshal != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 313| 1| g_return_if_fail (closure->is_invalid == FALSE); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 314| 1| g_return_if_fail (closure->in_marshal == FALSE); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 315| | 316| 1| real_closure = G_REAL_CLOSURE (closure); ------------------ | | 63| 1| ((GRealClosure *)G_STRUCT_MEMBER_P ((_c), -G_STRUCT_OFFSET (GRealClosure, closure))) | | ------------------ | | | | 860| 1| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 317| | 318| 1| g_return_if_fail (real_closure->meta_marshal != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 319| | 320| 1| real_closure->va_meta_marshal = va_meta_marshal; 321| 1|} _g_enum_types_init: 89| 2|{ 90| 2| static gboolean initialized = FALSE; ------------------ | | 814| 2|#define FALSE (0) ------------------ 91| 2| static const GTypeValueTable flags_enum_value_table = { 92| 2| value_flags_enum_init, /* value_init */ 93| 2| NULL, /* value_free */ 94| 2| value_flags_enum_copy_value, /* value_copy */ 95| 2| NULL, /* value_peek_pointer */ 96| 2| "i", /* collect_format */ 97| 2| value_flags_enum_collect_value, /* collect_value */ 98| 2| "p", /* lcopy_format */ 99| 2| value_flags_enum_lcopy_value, /* lcopy_value */ 100| 2| }; 101| 2| GTypeInfo info = { 102| 2| 0, /* class_size */ 103| 2| NULL, /* base_init */ 104| 2| NULL, /* base_destroy */ 105| 2| NULL, /* class_init */ 106| 2| NULL, /* class_destroy */ 107| 2| NULL, /* class_data */ 108| 2| 0, /* instance_size */ 109| 2| 0, /* n_preallocs */ 110| 2| NULL, /* instance_init */ 111| 2| &flags_enum_value_table, /* value_table */ 112| 2| }; 113| 2| static const GTypeFundamentalInfo finfo = { 114| 2| G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_DERIVABLE, 115| 2| }; 116| 2| GType type G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */; 117| | 118| 2| g_return_if_fail (initialized == FALSE); ------------------ | | 630| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 631| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 632| 2| { } \ | | 633| 2| else \ | | 634| 2| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 119| 2| initialized = TRUE; ------------------ | | 818| 2|#define TRUE (!FALSE) | | ------------------ | | | | 814| 2|#define FALSE (0) | | ------------------ ------------------ 120| | 121| | /* G_TYPE_ENUM 122| | */ 123| 2| info.class_size = sizeof (GEnumClass); 124| 2| type = g_type_register_fundamental (G_TYPE_ENUM, g_intern_static_string ("GEnum"), &info, &finfo, ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 125| 2| G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT); 126| 2| g_assert (type == G_TYPE_ENUM); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 127| | 128| | /* G_TYPE_FLAGS 129| | */ 130| 2| info.class_size = sizeof (GFlagsClass); 131| 2| type = g_type_register_fundamental (G_TYPE_FLAGS, g_intern_static_string ("GFlags"), &info, &finfo, ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 132| 2| G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT); 133| 2| g_assert (type == G_TYPE_FLAGS); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 134| 2|} _g_object_type_init: 403| 2|{ 404| 2| static gboolean initialized = FALSE; ------------------ | | 814| 2|#define FALSE (0) ------------------ 405| 2| static const GTypeFundamentalInfo finfo = { 406| 2| G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE, 407| 2| }; 408| 2| GTypeInfo info = { 409| 2| sizeof (GObjectClass), 410| 2| (GBaseInitFunc) g_object_base_class_init, 411| 2| (GBaseFinalizeFunc) g_object_base_class_finalize, 412| 2| (GClassInitFunc) g_object_do_class_init, 413| 2| NULL /* class_destroy */, 414| 2| NULL /* class_data */, 415| 2| sizeof (GObject), 416| 2| 0 /* n_preallocs */, 417| 2| (GInstanceInitFunc) g_object_init, 418| 2| NULL, /* value_table */ 419| 2| }; 420| 2| static const GTypeValueTable value_table = { 421| 2| g_value_object_init, /* value_init */ 422| 2| g_value_object_free_value, /* value_free */ 423| 2| g_value_object_copy_value, /* value_copy */ 424| 2| g_value_object_peek_pointer, /* value_peek_pointer */ 425| 2| "p", /* collect_format */ 426| 2| g_value_object_collect_value, /* collect_value */ 427| 2| "p", /* lcopy_format */ 428| 2| g_value_object_lcopy_value, /* lcopy_value */ 429| 2| }; 430| 2| GType type G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */; 431| | 432| 2| g_return_if_fail (initialized == FALSE); ------------------ | | 630| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 631| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 632| 2| { } \ | | 633| 2| else \ | | 634| 2| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 433| 2| initialized = TRUE; ------------------ | | 818| 2|#define TRUE (!FALSE) | | ------------------ | | | | 814| 2|#define FALSE (0) | | ------------------ ------------------ 434| | 435| | /* G_TYPE_OBJECT 436| | */ 437| 2| info.value_table = &value_table; 438| 2| type = g_type_register_fundamental (G_TYPE_OBJECT, g_intern_static_string ("GObject"), &info, &finfo, 0); ------------------ | | 178| 2|#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 439| 2| g_assert (type == G_TYPE_OBJECT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 440| 2| g_value_register_transform_func (G_TYPE_OBJECT, G_TYPE_OBJECT, g_value_object_transform_value); ------------------ | | 178| 2|#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_OBJECT, G_TYPE_OBJECT, g_value_object_transform_value); ------------------ | | 178| 2|#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 441| | 442| 2|#if G_ENABLE_DEBUG 443| | /* We cannot use GOBJECT_IF_DEBUG here because of the G_HAS_CONSTRUCTORS 444| | * conditional in between, as the C spec leaves conditionals inside macro 445| | * expansions as undefined behavior. Only GCC and Clang are known to work 446| | * but compilation breaks on MSVC. 447| | * 448| | * See: https://bugzilla.gnome.org/show_bug.cgi?id=769504 449| | */ 450| 2| if (_g_type_debug_flags & G_TYPE_DEBUG_OBJECTS) \ ------------------ | Branch (450:7): [True: 0, False: 2] ------------------ 451| 0| { 452| 0| debug_objects_ht = g_hash_table_new (g_direct_hash, NULL); 453| |# ifndef G_HAS_CONSTRUCTORS 454| | g_atexit (debug_objects_atexit); 455| |# endif /* G_HAS_CONSTRUCTORS */ 456| 0| } 457| 2|#endif /* G_ENABLE_DEBUG */ 458| 2|} g_object_class_install_property: 656| 1|{ 657| 1| GType oclass_type, parent_type; 658| | 659| 1| g_return_if_fail (G_IS_OBJECT_CLASS (class)); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 5| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 1] | | | | | | | Branch (1018:8): [True: 0, False: 1] | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 660| 1| g_return_if_fail (property_id > 0); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 661| | 662| 1| oclass_type = G_OBJECT_CLASS_TYPE (class); ------------------ | | 119| 1|#define G_OBJECT_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class)) | | ------------------ | | | | 613| 1|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) | | ------------------ ------------------ 663| 1| parent_type = g_type_parent (oclass_type); 664| | 665| 1| if (CLASS_HAS_DERIVED_CLASS (class)) ------------------ | | 151| 1| ((class)->flags & CLASS_HAS_DERIVED_CLASS_FLAG) | | ------------------ | | | | 149| 1|#define CLASS_HAS_DERIVED_CLASS_FLAG 0x2 | | ------------------ | | | Branch (151:5): [True: 0, False: 1] | | ------------------ ------------------ 666| 1| g_error ("Attempt to add property %s::%s to class after it was derived", G_OBJECT_CLASS_NAME (class), pspec->name); ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 667| | 668| 1| (void) validate_and_install_class_property (class, 669| 1| oclass_type, 670| 1| parent_type, 671| 1| property_id, 672| 1| pspec); 673| 1|} _g_object_has_signal_handler: 1067| 3.85k|{ 1068| 3.85k|#ifdef HAVE_OPTIONAL_FLAGS 1069| 3.85k| return (object_get_optional_flags (object) & OPTIONAL_FLAG_HAS_SIGNAL_HANDLER) != 0; ------------------ | | 166| 3.85k|#define OPTIONAL_FLAG_HAS_SIGNAL_HANDLER 1<<1 /* Set if object ever had a signal handler */ ------------------ 1070| |#else 1071| | return TRUE; 1072| |#endif 1073| 3.85k|} g_object_new: 1773| 7.70k|{ 1774| 7.70k| GObject *object; 1775| 7.70k| va_list var_args; 1776| | 1777| | /* short circuit for calls supplying no properties */ 1778| 7.70k| if (!first_property_name) ------------------ | Branch (1778:7): [True: 7.70k, False: 0] ------------------ 1779| 7.70k| return g_object_new_with_properties (object_type, 0, NULL, NULL); 1780| | 1781| 7.70k| va_start (var_args, first_property_name); 1782| 0| object = g_object_new_valist (object_type, first_property_name, var_args); 1783| 0| va_end (var_args); 1784| | 1785| 0| return object; 1786| 7.70k|} g_object_new_with_properties: 2066| 7.70k|{ 2067| 7.70k| GObjectClass *class, *unref_class = NULL; 2068| 7.70k| GObject *object; 2069| | 2070| 7.70k| g_return_val_if_fail (G_TYPE_IS_OBJECT (object_type), NULL); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 2071| | 2072| | /* Try to avoid thrashing the ref_count if we don't need to (since 2073| | * it's a locked operation). 2074| | */ 2075| 7.70k| class = g_type_class_peek_static (object_type); 2076| | 2077| 7.70k| if (class == NULL) ------------------ | Branch (2077:7): [True: 2, False: 7.70k] ------------------ 2078| 2| class = unref_class = g_type_class_ref (object_type); 2079| | 2080| 7.70k| if (n_properties > 0) ------------------ | Branch (2080:7): [True: 0, False: 7.70k] ------------------ 2081| 0| { 2082| 0| guint i, count = 0; 2083| 0| GObjectConstructParam *params; 2084| | 2085| 0| params = g_newa (GObjectConstructParam, n_properties); ------------------ | | 101| 0|#define g_newa(struct_type, n_structs) ((struct_type*) g_alloca (sizeof (struct_type) * (gsize) (n_structs))) | | ------------------ | | | | 91| 0|#define g_alloca(size) alloca (size) | | ------------------ ------------------ 2086| 0| for (i = 0; i < n_properties; i++) ------------------ | Branch (2086:19): [True: 0, False: 0] ------------------ 2087| 0| { 2088| 0| GParamSpec *pspec; 2089| 0| pspec = g_param_spec_pool_lookup (pspec_pool, names[i], object_type, TRUE); ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 2090| 0| if (!g_object_new_is_valid_property (object_type, pspec, names[i], params, count)) ------------------ | Branch (2090:15): [True: 0, False: 0] ------------------ 2091| 0| continue; 2092| 0| params[count].pspec = pspec; 2093| | 2094| | /* Init GValue */ 2095| 0| params[count].value = g_newa (GValue, 1); ------------------ | | 101| 0|#define g_newa(struct_type, n_structs) ((struct_type*) g_alloca (sizeof (struct_type) * (gsize) (n_structs))) | | ------------------ | | | | 91| 0|#define g_alloca(size) alloca (size) | | ------------------ ------------------ 2096| 0| memset (params[count].value, 0, sizeof (GValue)); 2097| 0| g_value_init (params[count].value, G_VALUE_TYPE (&values[i])); ------------------ | | 59| 0|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ 2098| | 2099| 0| g_value_copy (&values[i], params[count].value); 2100| 0| count++; 2101| 0| } 2102| 0| object = g_object_new_internal (class, params, count); 2103| | 2104| 0| while (count--) ------------------ | Branch (2104:14): [True: 0, False: 0] ------------------ 2105| 0| g_value_unset (params[count].value); 2106| 0| } 2107| 7.70k| else 2108| 7.70k| object = g_object_new_internal (class, NULL, 0); 2109| | 2110| 7.70k| if (unref_class != NULL) ------------------ | Branch (2110:7): [True: 2, False: 7.70k] ------------------ 2111| 2| g_type_class_unref (unref_class); 2112| | 2113| 7.70k| return object; 2114| 7.70k|} g_object_ref: 3384| 7.70k|{ 3385| 7.70k| GObject *object = _object; 3386| 7.70k| gint old_val; 3387| 7.70k| gboolean object_already_finalized; 3388| | 3389| 7.70k| g_return_val_if_fail (G_IS_OBJECT (object), NULL); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 3390| | 3391| 7.70k| old_val = g_atomic_int_add (&object->ref_count, 1); ------------------ | | 167| 7.70k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 168| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 169| 7.70k| (void) (0 ? *(atomic) ^ (val) : 1); \ | | ------------------ | | | Branch (169:13): [Folded, False: 7.70k] | | ------------------ | | 170| 7.70k| (gint) __atomic_fetch_add ((atomic), (val), __ATOMIC_SEQ_CST); \ | | 171| 7.70k| })) ------------------ 3392| 7.70k| object_already_finalized = (old_val <= 0); 3393| 7.70k| g_return_val_if_fail (!object_already_finalized, NULL); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 3394| | 3395| 7.70k| if (old_val == 1 && OBJECT_HAS_TOGGLE_REF (object)) ------------------ | | 138| 3.85k| ((g_datalist_get_flags (&(object)->qdata) & OBJECT_HAS_TOGGLE_REF_FLAG) != 0) | | ------------------ | | | | 136| 3.85k|#define OBJECT_HAS_TOGGLE_REF_FLAG 0x1 | | ------------------ | | | Branch (138:5): [True: 0, False: 3.85k] | | ------------------ ------------------ | Branch (3395:7): [True: 3.85k, False: 3.85k] ------------------ 3396| 0| toggle_refs_notify (object, FALSE); ------------------ | | 814| 0|#define FALSE (0) ------------------ 3397| | 3398| 7.70k| TRACE (GOBJECT_OBJECT_REF(object,G_TYPE_FROM_INSTANCE(object),old_val)); 3399| | 3400| 7.70k| return object; 3401| 7.70k|} g_object_unref: 3417| 15.4k|{ 3418| 15.4k| GObject *object = _object; 3419| 15.4k| gint old_ref; 3420| | 3421| 15.4k| g_return_if_fail (G_IS_OBJECT (object)); ------------------ | | 630| 15.4k| G_STMT_START { \ | | ------------------ | | | | 874| 15.4k|#define G_STMT_START do | | ------------------ | | 631| 15.4k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 15.4k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 15.4k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 15.4k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 15.4k| int _g_boolean_var_; \ | | | | | | 1018| 15.4k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 15.4k, False: 0] | | | | | | ------------------ | | | | | | 1019| 15.4k| _g_boolean_var_ = 1; \ | | | | | | 1020| 15.4k| else \ | | | | | | 1021| 15.4k| _g_boolean_var_ = 0; \ | | | | | | 1022| 15.4k| _g_boolean_var_; \ | | | | | | 1023| 15.4k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 15.4k, False: 0] | | | | ------------------ | | ------------------ | | 632| 15.4k| { } \ | | 633| 15.4k| else \ | | 634| 15.4k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 15.4k| } G_STMT_END | | ------------------ | | | | 882| 15.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 15.4k] | | | | ------------------ | | ------------------ ------------------ 3422| | 3423| | /* here we want to atomically do: if (ref_count>1) { ref_count--; return; } */ 3424| 15.4k| retry_atomic_decrement1: 3425| 15.4k| old_ref = g_atomic_int_get (&object->ref_count); ------------------ | | 96| 15.4k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 15.4k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 15.4k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 15.4k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 15.4k| gint gaig_temp; \ | | 99| 15.4k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 15.4k] | | ------------------ | | 100| 15.4k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 15.4k| (gint) gaig_temp; \ | | 102| 15.4k| })) ------------------ 3426| 15.4k| if (old_ref > 1) ------------------ | Branch (3426:7): [True: 7.70k, False: 7.70k] ------------------ 3427| 7.70k| { 3428| | /* valid if last 2 refs are owned by this call to unref and the toggle_ref */ 3429| 7.70k| gboolean has_toggle_ref = OBJECT_HAS_TOGGLE_REF (object); ------------------ | | 138| 7.70k| ((g_datalist_get_flags (&(object)->qdata) & OBJECT_HAS_TOGGLE_REF_FLAG) != 0) | | ------------------ | | | | 136| 7.70k|#define OBJECT_HAS_TOGGLE_REF_FLAG 0x1 | | ------------------ ------------------ 3430| | 3431| 7.70k| if (!g_atomic_int_compare_and_exchange ((int *)&object->ref_count, old_ref, old_ref - 1)) ------------------ | | 160| 7.70k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 161| 7.70k| gint gaicae_oldval = (oldval); \ | | 162| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 163| 7.70k| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | ------------------ | | | Branch (163:13): [Folded, False: 7.70k] | | ------------------ | | 164| 7.70k| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 7.70k|#define FALSE (0) | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 818| 7.70k|#define TRUE (!FALSE) | | | | ------------------ | | | | | | 814| 7.70k|#define FALSE (0) | | | | ------------------ | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (164:5): [True: 7.70k, False: 0] | | ------------------ | | 165| 7.70k| })) ------------------ | Branch (3431:11): [True: 0, False: 7.70k] ------------------ 3432| 0| goto retry_atomic_decrement1; 3433| | 3434| 7.70k| TRACE (GOBJECT_OBJECT_UNREF(object,G_TYPE_FROM_INSTANCE(object),old_ref)); 3435| | 3436| | /* if we went from 2->1 we need to notify toggle refs if any */ 3437| 7.70k| if (old_ref == 2 && has_toggle_ref) /* The last ref being held in this case is owned by the toggle_ref */ ------------------ | Branch (3437:11): [True: 3.85k, False: 3.85k] | Branch (3437:27): [True: 0, False: 3.85k] ------------------ 3438| 0| toggle_refs_notify (object, TRUE); ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 3439| 7.70k| } 3440| 7.70k| else 3441| 7.70k| { 3442| 7.70k| GSList **weak_locations; 3443| | 3444| | /* The only way that this object can live at this point is if 3445| | * there are outstanding weak references already established 3446| | * before we got here. 3447| | * 3448| | * If there were not already weak references then no more can be 3449| | * established at this time, because the other thread would have 3450| | * to hold a strong ref in order to call 3451| | * g_object_add_weak_pointer() and then we wouldn't be here. 3452| | */ 3453| 7.70k| weak_locations = g_datalist_id_get_data (&object->qdata, quark_weak_locations); 3454| | 3455| 7.70k| if (weak_locations != NULL) ------------------ | Branch (3455:11): [True: 0, False: 7.70k] ------------------ 3456| 0| { 3457| 0| g_rw_lock_writer_lock (&weak_locations_lock); 3458| | 3459| | /* It is possible that one of the weak references beat us to 3460| | * the lock. Make sure the refcount is still what we expected 3461| | * it to be. 3462| | */ 3463| 0| old_ref = g_atomic_int_get (&object->ref_count); ------------------ | | 96| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 0| gint gaig_temp; \ | | 99| 0| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 0] | | ------------------ | | 100| 0| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 0| (gint) gaig_temp; \ | | 102| 0| })) ------------------ 3464| 0| if (old_ref != 1) ------------------ | Branch (3464:15): [True: 0, False: 0] ------------------ 3465| 0| { 3466| 0| g_rw_lock_writer_unlock (&weak_locations_lock); 3467| 0| goto retry_atomic_decrement1; 3468| 0| } 3469| | 3470| | /* We got the lock first, so the object will definitely die 3471| | * now. Clear out all the weak references. 3472| | */ 3473| 0| while (*weak_locations) ------------------ | Branch (3473:18): [True: 0, False: 0] ------------------ 3474| 0| { 3475| 0| GWeakRef *weak_ref_location = (*weak_locations)->data; 3476| | 3477| 0| weak_ref_location->priv.p = NULL; 3478| 0| *weak_locations = g_slist_delete_link (*weak_locations, *weak_locations); 3479| 0| } 3480| | 3481| 0| g_rw_lock_writer_unlock (&weak_locations_lock); 3482| 0| } 3483| | 3484| | /* we are about to remove the last reference */ 3485| 7.70k| TRACE (GOBJECT_OBJECT_DISPOSE(object,G_TYPE_FROM_INSTANCE(object), 1)); 3486| 7.70k| G_OBJECT_GET_CLASS (object)->dispose (object); ------------------ | | 91| 7.70k|#define G_OBJECT_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 527| 7.70k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 7.70k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ 3487| 7.70k| TRACE (GOBJECT_OBJECT_DISPOSE_END(object,G_TYPE_FROM_INSTANCE(object), 1)); 3488| | 3489| | /* may have been re-referenced meanwhile */ 3490| 7.70k| retry_atomic_decrement2: 3491| 7.70k| old_ref = g_atomic_int_get ((int *)&object->ref_count); ------------------ | | 96| 7.70k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 7.70k| gint gaig_temp; \ | | 99| 7.70k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 7.70k] | | ------------------ | | 100| 7.70k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 7.70k| (gint) gaig_temp; \ | | 102| 7.70k| })) ------------------ 3492| 7.70k| if (old_ref > 1) ------------------ | Branch (3492:11): [True: 0, False: 7.70k] ------------------ 3493| 0| { 3494| | /* valid if last 2 refs are owned by this call to unref and the toggle_ref */ 3495| 0| gboolean has_toggle_ref = OBJECT_HAS_TOGGLE_REF (object); ------------------ | | 138| 0| ((g_datalist_get_flags (&(object)->qdata) & OBJECT_HAS_TOGGLE_REF_FLAG) != 0) | | ------------------ | | | | 136| 0|#define OBJECT_HAS_TOGGLE_REF_FLAG 0x1 | | ------------------ ------------------ 3496| | 3497| 0| if (!g_atomic_int_compare_and_exchange ((int *)&object->ref_count, old_ref, old_ref - 1)) ------------------ | | 160| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 161| 0| gint gaicae_oldval = (oldval); \ | | 162| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 163| 0| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | ------------------ | | | Branch (163:13): [Folded, False: 0] | | ------------------ | | 164| 0| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 818| 0|#define TRUE (!FALSE) | | | | ------------------ | | | | | | 814| 0|#define FALSE (0) | | | | ------------------ | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (164:5): [True: 0, False: 0] | | ------------------ | | 165| 0| })) ------------------ | Branch (3497:15): [True: 0, False: 0] ------------------ 3498| 0| goto retry_atomic_decrement2; 3499| | 3500| 0| TRACE (GOBJECT_OBJECT_UNREF(object,G_TYPE_FROM_INSTANCE(object),old_ref)); 3501| | 3502| | /* if we went from 2->1 we need to notify toggle refs if any */ 3503| 0| if (old_ref == 2 && has_toggle_ref) /* The last ref being held in this case is owned by the toggle_ref */ ------------------ | Branch (3503:15): [True: 0, False: 0] | Branch (3503:31): [True: 0, False: 0] ------------------ 3504| 0| toggle_refs_notify (object, TRUE); ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 3505| | 3506| 0| return; 3507| 0| } 3508| | 3509| | /* we are still in the process of taking away the last ref */ 3510| 7.70k| g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL); ------------------ | | 99| 7.70k| g_datalist_id_set_data_full ((dl), (q), (d), NULL) ------------------ 3511| 7.70k| g_signal_handlers_destroy (object); 3512| 7.70k| g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL); ------------------ | | 99| 7.70k| g_datalist_id_set_data_full ((dl), (q), (d), NULL) ------------------ 3513| | 3514| | /* decrement the last reference */ 3515| 7.70k| old_ref = g_atomic_int_add (&object->ref_count, -1); ------------------ | | 167| 7.70k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 168| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 169| 7.70k| (void) (0 ? *(atomic) ^ (val) : 1); \ | | ------------------ | | | Branch (169:13): [Folded, False: 7.70k] | | ------------------ | | 170| 7.70k| (gint) __atomic_fetch_add ((atomic), (val), __ATOMIC_SEQ_CST); \ | | 171| 7.70k| })) ------------------ 3516| 7.70k| g_return_if_fail (old_ref > 0); ------------------ | | 630| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 631| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 632| 7.70k| { } \ | | 633| 7.70k| else \ | | 634| 7.70k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 3517| | 3518| 7.70k| TRACE (GOBJECT_OBJECT_UNREF(object,G_TYPE_FROM_INSTANCE(object),old_ref)); 3519| | 3520| | /* may have been re-referenced meanwhile */ 3521| 7.70k| if (G_LIKELY (old_ref == 1)) ------------------ | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | 1018| 7.70k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | ------------------ | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | 1020| 7.70k| else \ | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | 1023| 7.70k|}) | | ------------------ | | | Branch (1024:24): [True: 7.70k, False: 0] | | ------------------ ------------------ 3522| 7.70k| { 3523| 7.70k| TRACE (GOBJECT_OBJECT_FINALIZE(object,G_TYPE_FROM_INSTANCE(object))); 3524| 7.70k| G_OBJECT_GET_CLASS (object)->finalize (object); ------------------ | | 91| 7.70k|#define G_OBJECT_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 527| 7.70k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 7.70k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ 3525| | 3526| 7.70k| TRACE (GOBJECT_OBJECT_FINALIZE_END(object,G_TYPE_FROM_INSTANCE(object))); 3527| | 3528| 7.70k| GOBJECT_IF_DEBUG (OBJECTS, ------------------ | | 37| 7.70k|#define GOBJECT_IF_DEBUG(debug_type, code_block) \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 38| 7.70k|G_STMT_START { \ | | 39| 7.70k| if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type) \ | | ------------------ | | | Branch (39:9): [True: 0, False: 7.70k] | | ------------------ | | 40| 7.70k| { code_block; } \ | | ------------------ | | | Branch (40:9): [True: 0, False: 0] | | ------------------ | | 41| 7.70k|} G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 3529| 7.70k| { 3530| 7.70k| gboolean was_present; 3531| | 3532| | /* catch objects not chaining finalize handlers */ 3533| 7.70k| G_LOCK (debug_objects); 3534| 7.70k| was_present = g_hash_table_remove (debug_objects_ht, object); 3535| 7.70k| G_UNLOCK (debug_objects); 3536| | 3537| 7.70k| if (was_present) 3538| 7.70k| g_critical ("Object %p of type %s not finalized correctly.", 3539| 7.70k| object, G_OBJECT_TYPE_NAME (object)); 3540| 7.70k| }); 3541| 7.70k| g_type_free_instance ((GTypeInstance*) object); 3542| 7.70k| } 3543| 7.70k| } 3544| 15.4k|} g_value_get_object: 4164| 3.85k|{ 4165| 3.85k| g_return_val_if_fail (G_VALUE_HOLDS_OBJECT (value), NULL); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 19.2k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 4166| | 4167| 3.85k| return value->data[0].v_pointer; 4168| 3.85k|} gobject.c:g_object_base_class_init: 462| 5|{ 463| 5| GObjectClass *pclass = g_type_class_peek_parent (class); 464| | 465| | /* Don't inherit HAS_DERIVED_CLASS flag from parent class */ 466| 5| class->flags &= ~CLASS_HAS_DERIVED_CLASS_FLAG; ------------------ | | 149| 5|#define CLASS_HAS_DERIVED_CLASS_FLAG 0x2 ------------------ 467| | 468| 5| if (pclass) ------------------ | Branch (468:7): [True: 4, False: 1] ------------------ 469| 4| pclass->flags |= CLASS_HAS_DERIVED_CLASS_FLAG; ------------------ | | 149| 4|#define CLASS_HAS_DERIVED_CLASS_FLAG 0x2 ------------------ 470| | 471| | /* reset instance specific fields and methods that don't get inherited */ 472| 5| class->construct_properties = pclass ? g_slist_copy (pclass->construct_properties) : NULL; ------------------ | Branch (472:33): [True: 4, False: 1] ------------------ 473| 5| class->get_property = NULL; 474| | class->set_property = NULL; 475| 5|} gobject.c:g_object_do_class_init: 500| 1|{ 501| | /* read the comment about typedef struct CArray; on why not to change this quark */ 502| 1| quark_closure_array = g_quark_from_static_string ("GObject-closure-array"); 503| | 504| 1| quark_weak_refs = g_quark_from_static_string ("GObject-weak-references"); 505| 1| quark_weak_locations = g_quark_from_static_string ("GObject-weak-locations"); 506| 1| quark_toggle_refs = g_quark_from_static_string ("GObject-toggle-references"); 507| 1| quark_notify_queue = g_quark_from_static_string ("GObject-notify-queue"); 508| 1| quark_in_construction = g_quark_from_static_string ("GObject-in-construction"); 509| 1| pspec_pool = g_param_spec_pool_new (TRUE); ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 510| | 511| 1| class->constructor = g_object_constructor; 512| 1| class->constructed = g_object_constructed; 513| 1| class->set_property = g_object_do_set_property; 514| 1| class->get_property = g_object_do_get_property; 515| 1| class->dispose = g_object_real_dispose; 516| 1| class->finalize = g_object_finalize; 517| 1| class->dispatch_properties_changed = g_object_dispatch_properties_changed; 518| 1| class->notify = NULL; 519| | 520| | /** 521| | * GObject::notify: 522| | * @gobject: the object which received the signal. 523| | * @pspec: the #GParamSpec of the property which changed. 524| | * 525| | * The notify signal is emitted on an object when one of its properties has 526| | * its value set through g_object_set_property(), g_object_set(), et al. 527| | * 528| | * Note that getting this signal doesn’t itself guarantee that the value of 529| | * the property has actually changed. When it is emitted is determined by the 530| | * derived GObject class. If the implementor did not create the property with 531| | * %G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results 532| | * in ::notify being emitted, even if the new value is the same as the old. 533| | * If they did pass %G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only 534| | * when they explicitly call g_object_notify() or g_object_notify_by_pspec(), 535| | * and common practice is to do that only when the value has actually changed. 536| | * 537| | * This signal is typically used to obtain change notification for a 538| | * single property, by specifying the property name as a detail in the 539| | * g_signal_connect() call, like this: 540| | * |[ 541| | * g_signal_connect (text_view->buffer, "notify::paste-target-list", 542| | * G_CALLBACK (gtk_text_view_target_list_notify), 543| | * text_view) 544| | * ]| 545| | * It is important to note that you must use 546| | * [canonical parameter names][canonical-parameter-names] as 547| | * detail strings for the notify signal. 548| | */ 549| 1| gobject_signals[NOTIFY] = 550| 1| g_signal_new (g_intern_static_string ("notify"), 551| 1| G_TYPE_FROM_CLASS (class), ------------------ | | 613| 1|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) ------------------ 552| 1| G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED | G_SIGNAL_NO_HOOKS | G_SIGNAL_ACTION, 553| 1| G_STRUCT_OFFSET (GObjectClass, notify), ------------------ | | 853| 1| ((glong) offsetof (struct_type, member)) ------------------ 554| 1| NULL, NULL, 555| 1| NULL, 556| 1| G_TYPE_NONE, ------------------ | | 62| 1|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 557| 1| 1, G_TYPE_PARAM); ------------------ | | 172| 1|#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) | | ------------------ | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 558| | 559| | /* Install a check function that we'll use to verify that classes that 560| | * implement an interface implement all properties for that interface 561| | */ 562| | g_type_add_interface_check (NULL, object_interface_check_properties); 563| 1|} gobject.c:g_object_constructed: 2339| 3.85k|{ 2340| | /* empty default impl to allow unconditional upchaining */ 2341| 3.85k|} gobject.c:g_object_real_dispose: 1171| 7.70k|{ 1172| 7.70k| g_signal_handlers_destroy (object); 1173| 7.70k| g_datalist_id_set_data (&object->qdata, quark_closure_array, NULL); ------------------ | | 99| 7.70k| g_datalist_id_set_data_full ((dl), (q), (d), NULL) ------------------ 1174| | g_datalist_id_set_data (&object->qdata, quark_weak_refs, NULL); ------------------ | | 99| 7.70k| g_datalist_id_set_data_full ((dl), (q), (d), NULL) ------------------ 1175| 7.70k|} gobject.c:g_object_finalize: 1179| 7.70k|{ 1180| 7.70k| if (object_in_construction (object)) ------------------ | Branch (1180:7): [True: 0, False: 7.70k] ------------------ 1181| 0| { 1182| 0| g_critical ("object %s %p finalized while still in-construction", ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1183| 0| G_OBJECT_TYPE_NAME (object), object); 1184| 0| } 1185| | 1186| 7.70k| g_datalist_clear (&object->qdata); 1187| | 1188| 7.70k| GOBJECT_IF_DEBUG (OBJECTS, ------------------ | | 37| 7.70k|#define GOBJECT_IF_DEBUG(debug_type, code_block) \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 38| 7.70k|G_STMT_START { \ | | 39| 7.70k| if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type) \ | | ------------------ | | | Branch (39:9): [True: 0, False: 7.70k] | | ------------------ | | 40| 7.70k| { code_block; } \ | | ------------------ | | | Branch (40:9): [True: 0, False: 0] | | | Branch (40:9): [True: 0, False: 0] | | | Branch (40:9): [Folded, False: 0] | | ------------------ | | 41| 7.70k|} G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 1189| 7.70k| { 1190| 7.70k| G_LOCK (debug_objects); 1191| 7.70k| g_assert (g_hash_table_contains (debug_objects_ht, object)); 1192| 7.70k| g_hash_table_remove (debug_objects_ht, object); 1193| 7.70k| debug_objects_count--; 1194| 7.70k| G_UNLOCK (debug_objects); 1195| 7.70k| }); 1196| 7.70k|} gobject.c:object_in_construction: 1085| 7.70k|{ 1086| 7.70k|#ifdef HAVE_OPTIONAL_FLAGS 1087| 7.70k| return (object_get_optional_flags (object) & OPTIONAL_FLAG_IN_CONSTRUCTION) != 0; ------------------ | | 165| 7.70k|#define OPTIONAL_FLAG_IN_CONSTRUCTION 1<<0 ------------------ 1088| |#else 1089| | return g_datalist_id_get_data (&object->qdata, quark_in_construction) != NULL; 1090| |#endif 1091| 7.70k|} gobject.c:g_object_dispatch_properties_changed: 1202| 3.85k|{ 1203| 3.85k| guint i; 1204| | 1205| 7.70k| for (i = 0; i < n_pspecs; i++) ------------------ | Branch (1205:15): [True: 3.85k, False: 3.85k] ------------------ 1206| 3.85k| g_signal_emit (object, gobject_signals[NOTIFY], g_param_spec_get_name_quark (pspecs[i]), pspecs[i]); 1207| 3.85k|} gobject.c:object_interface_check_properties: 1583| 3|{ 1584| 3| GTypeInterface *iface_class = g_iface; 1585| 3| GObjectClass *class; 1586| 3| GType iface_type = iface_class->g_type; 1587| 3| GParamSpec **pspecs; 1588| 3| guint n; 1589| | 1590| 3| class = g_type_class_ref (iface_class->g_instance_type); 1591| | 1592| 3| if (class == NULL) ------------------ | Branch (1592:7): [True: 0, False: 3] ------------------ 1593| 0| return; 1594| | 1595| 3| if (!G_IS_OBJECT_CLASS (class)) ------------------ | | 82| 3|#define G_IS_OBJECT_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_OBJECT)) | | ------------------ | | | | 566| 3|#define G_TYPE_CHECK_CLASS_TYPE(g_class, g_type) (_G_TYPE_CCT ((g_class), (g_type))) | | | | ------------------ | | | | | | 2323| 3|# define _G_TYPE_CCT(cp, gt) (G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 2324| 3| GTypeClass *__class = (GTypeClass*) cp; GType __t = gt; gboolean __r; \ | | | | | | 2325| 3| if (!__class) \ | | | | | | ------------------ | | | | | | | Branch (2325:7): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 2326| 3| __r = FALSE; \ | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | | | 2327| 3| else if (__class->g_type == __t) \ | | | | | | ------------------ | | | | | | | Branch (2327:12): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 2328| 3| __r = TRUE; \ | | | | | | ------------------ | | | | | | | | 818| 0|#define TRUE (!FALSE) | | | | | | | | ------------------ | | | | | | | | | | 814| 0|#define FALSE (0) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 2329| 3| else \ | | | | | | 2330| 3| __r = g_type_check_class_is_a (__class, __t); \ | | | | | | 2331| 3| __r; \ | | | | | | 2332| 3|})) | | | | ------------------ | | ------------------ ------------------ | Branch (1595:7): [True: 0, False: 3] ------------------ 1596| 0| goto out; 1597| | 1598| 3| pspecs = g_param_spec_pool_list (pspec_pool, iface_type, &n); 1599| | 1600| 3| while (n--) ------------------ | Branch (1600:10): [True: 0, False: 3] ------------------ 1601| 0| { 1602| 0| GParamSpec *class_pspec = g_param_spec_pool_lookup (pspec_pool, 1603| 0| pspecs[n]->name, 1604| 0| G_OBJECT_CLASS_TYPE (class), ------------------ | | 119| 0|#define G_OBJECT_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class)) | | ------------------ | | | | 613| 0|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) | | ------------------ ------------------ 1605| 0| TRUE); ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 1606| | 1607| 0| if (!class_pspec) ------------------ | Branch (1607:11): [True: 0, False: 0] ------------------ 1608| 0| { 1609| 0| g_critical ("Object class %s doesn't implement property " ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1610| 0| "'%s' from interface '%s'", 1611| 0| g_type_name (G_OBJECT_CLASS_TYPE (class)), 1612| 0| pspecs[n]->name, 1613| 0| g_type_name (iface_type)); 1614| | 1615| 0| continue; 1616| 0| } 1617| | 1618| | /* We do a number of checks on the properties of an interface to 1619| | * make sure that all classes implementing the interface are 1620| | * overriding the properties correctly. 1621| | * 1622| | * We do the checks in order of importance so that we can give 1623| | * more useful error messages first. 1624| | * 1625| | * First, we check that the implementation doesn't remove the 1626| | * basic functionality (readability, writability) advertised by 1627| | * the interface. Next, we check that it doesn't introduce 1628| | * additional restrictions (such as construct-only). Finally, we 1629| | * make sure the types are compatible. 1630| | */ 1631| | 1632| 0|#define SUBSET(a,b,mask) (((a) & ~(b) & (mask)) == 0) 1633| | /* If the property on the interface is readable then the 1634| | * implementation must be readable. If the interface is writable 1635| | * then the implementation must be writable. 1636| | */ 1637| 0| if (!SUBSET (pspecs[n]->flags, class_pspec->flags, G_PARAM_READABLE | G_PARAM_WRITABLE)) ------------------ | | 1632| 0|#define SUBSET(a,b,mask) (((a) & ~(b) & (mask)) == 0) ------------------ | Branch (1637:11): [True: 0, False: 0] ------------------ 1638| 0| { 1639| 0| g_critical ("Flags for property '%s' on class '%s' remove functionality compared with the " ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1640| 0| "property on interface '%s'\n", pspecs[n]->name, 1641| 0| g_type_name (G_OBJECT_CLASS_TYPE (class)), g_type_name (iface_type)); 1642| 0| continue; 1643| 0| } 1644| | 1645| | /* If the property on the interface is writable then we need to 1646| | * make sure the implementation doesn't introduce new restrictions 1647| | * on that writability (ie: construct-only). 1648| | * 1649| | * If the interface was not writable to begin with then we don't 1650| | * really have any problems here because "writable at construct 1651| | * time only" is still more permissive than "read only". 1652| | */ 1653| 0| if (pspecs[n]->flags & G_PARAM_WRITABLE) ------------------ | Branch (1653:11): [True: 0, False: 0] ------------------ 1654| 0| { 1655| 0| if (!SUBSET (class_pspec->flags, pspecs[n]->flags, G_PARAM_CONSTRUCT_ONLY)) ------------------ | | 1632| 0|#define SUBSET(a,b,mask) (((a) & ~(b) & (mask)) == 0) ------------------ | Branch (1655:15): [True: 0, False: 0] ------------------ 1656| 0| { 1657| 0| g_critical ("Flags for property '%s' on class '%s' introduce additional restrictions on " ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1658| 0| "writability compared with the property on interface '%s'\n", pspecs[n]->name, 1659| 0| g_type_name (G_OBJECT_CLASS_TYPE (class)), g_type_name (iface_type)); 1660| 0| continue; 1661| 0| } 1662| 0| } 1663| 0|#undef SUBSET 1664| | 1665| | /* If the property on the interface is readable then we are 1666| | * effectively advertising that reading the property will return a 1667| | * value of a specific type. All implementations of the interface 1668| | * need to return items of this type -- but may be more 1669| | * restrictive. For example, it is legal to have: 1670| | * 1671| | * GtkWidget *get_item(); 1672| | * 1673| | * that is implemented by a function that always returns a 1674| | * GtkEntry. In short: readability implies that the 1675| | * implementation value type must be equal or more restrictive. 1676| | * 1677| | * Similarly, if the property on the interface is writable then 1678| | * must be able to accept the property being set to any value of 1679| | * that type, including subclasses. In this case, we may also be 1680| | * less restrictive. For example, it is legal to have: 1681| | * 1682| | * set_item (GtkEntry *); 1683| | * 1684| | * that is implemented by a function that will actually work with 1685| | * any GtkWidget. In short: writability implies that the 1686| | * implementation value type must be equal or less restrictive. 1687| | * 1688| | * In the case that the property is both readable and writable 1689| | * then the only way that both of the above can be satisfied is 1690| | * with a type that is exactly equal. 1691| | */ 1692| 0| switch (pspecs[n]->flags & (G_PARAM_READABLE | G_PARAM_WRITABLE)) 1693| 0| { 1694| 0| case G_PARAM_READABLE | G_PARAM_WRITABLE: ------------------ | Branch (1694:9): [True: 0, False: 0] ------------------ 1695| | /* class pspec value type must have exact equality with interface */ 1696| 0| if (pspecs[n]->value_type != class_pspec->value_type) ------------------ | Branch (1696:15): [True: 0, False: 0] ------------------ 1697| 0| g_critical ("Read/writable property '%s' on class '%s' has type '%s' which is not exactly equal to the " ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1698| 0| "type '%s' of the property on the interface '%s'\n", pspecs[n]->name, 1699| 0| g_type_name (G_OBJECT_CLASS_TYPE (class)), g_type_name (G_PARAM_SPEC_VALUE_TYPE (class_pspec)), 1700| 0| g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspecs[n])), g_type_name (iface_type)); 1701| 0| break; 1702| | 1703| 0| case G_PARAM_READABLE: ------------------ | Branch (1703:9): [True: 0, False: 0] ------------------ 1704| | /* class pspec value type equal or more restrictive than interface */ 1705| 0| if (!g_type_is_a (class_pspec->value_type, pspecs[n]->value_type)) ------------------ | Branch (1705:15): [True: 0, False: 0] ------------------ 1706| 0| g_critical ("Read-only property '%s' on class '%s' has type '%s' which is not equal to or more " ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1707| 0| "restrictive than the type '%s' of the property on the interface '%s'\n", pspecs[n]->name, 1708| 0| g_type_name (G_OBJECT_CLASS_TYPE (class)), g_type_name (G_PARAM_SPEC_VALUE_TYPE (class_pspec)), 1709| 0| g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspecs[n])), g_type_name (iface_type)); 1710| 0| break; 1711| | 1712| 0| case G_PARAM_WRITABLE: ------------------ | Branch (1712:9): [True: 0, False: 0] ------------------ 1713| | /* class pspec value type equal or less restrictive than interface */ 1714| 0| if (!g_type_is_a (pspecs[n]->value_type, class_pspec->value_type)) ------------------ | Branch (1714:15): [True: 0, False: 0] ------------------ 1715| 0| g_critical ("Write-only property '%s' on class '%s' has type '%s' which is not equal to or less " ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 1716| 0| "restrictive than the type '%s' of the property on the interface '%s' \n", pspecs[n]->name, 1717| 0| g_type_name (G_OBJECT_CLASS_TYPE (class)), g_type_name (G_PARAM_SPEC_VALUE_TYPE (class_pspec)), 1718| 0| g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspecs[n])), g_type_name (iface_type)); 1719| 0| break; 1720| | 1721| 0| default: ------------------ | Branch (1721:9): [True: 0, False: 0] ------------------ 1722| 0| g_assert_not_reached (); ------------------ | | 230| 0|#define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1723| 0| } 1724| 0| } 1725| | 1726| 3| g_free (pspecs); 1727| | 1728| 3| out: 1729| 3| g_type_class_unref (class); 1730| 3|} gobject.c:validate_and_install_class_property: 607| 1|{ 608| 1| if (!validate_pspec_to_install (pspec)) ------------------ | Branch (608:7): [True: 0, False: 1] ------------------ 609| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 610| | 611| 1| if (pspec->flags & G_PARAM_WRITABLE) ------------------ | Branch (611:7): [True: 1, False: 0] ------------------ 612| 1| g_return_val_if_fail (class->set_property != NULL, FALSE); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 613| 1| if (pspec->flags & G_PARAM_READABLE) ------------------ | Branch (613:7): [True: 1, False: 0] ------------------ 614| 1| g_return_val_if_fail (class->get_property != NULL, FALSE); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 615| | 616| 1| class->flags |= CLASS_HAS_PROPS_FLAG; ------------------ | | 141| 1|#define CLASS_HAS_PROPS_FLAG 0x1 ------------------ 617| 1| if (install_property_internal (oclass_type, property_id, pspec)) ------------------ | Branch (617:7): [True: 1, False: 0] ------------------ 618| 1| { 619| 1| if (pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) ------------------ | Branch (619:11): [True: 1, False: 0] ------------------ 620| 1| class->construct_properties = g_slist_append (class->construct_properties, pspec); 621| | 622| | /* for property overrides of construct properties, we have to get rid 623| | * of the overridden inherited construct property 624| | */ 625| 1| pspec = g_param_spec_pool_lookup (pspec_pool, pspec->name, parent_type, TRUE); ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 626| 1| if (pspec && pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) ------------------ | Branch (626:11): [True: 0, False: 1] | Branch (626:20): [True: 0, False: 0] ------------------ 627| 0| class->construct_properties = g_slist_remove (class->construct_properties, pspec); 628| | 629| 1| return TRUE; ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 630| 1| } 631| 0| else 632| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 633| 1|} gobject.c:validate_pspec_to_install: 586| 1|{ 587| 1| g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 588| 1| g_return_val_if_fail (PARAM_SPEC_PARAM_ID (pspec) == 0, FALSE); /* paranoid */ ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 589| | 590| 1| g_return_val_if_fail (pspec->flags & (G_PARAM_READABLE | G_PARAM_WRITABLE), FALSE); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 591| | 592| 1| if (pspec->flags & G_PARAM_CONSTRUCT) ------------------ | Branch (592:7): [True: 1, False: 0] ------------------ 593| 1| g_return_val_if_fail ((pspec->flags & G_PARAM_CONSTRUCT_ONLY) == 0, FALSE); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 594| | 595| 1| if (pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY)) ------------------ | Branch (595:7): [True: 1, False: 0] ------------------ 596| 1| g_return_val_if_fail (pspec->flags & G_PARAM_WRITABLE, FALSE); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 597| | 598| 1| return TRUE; ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 599| 1|} gobject.c:install_property_internal: 569| 1|{ 570| 1| if (g_param_spec_pool_lookup (pspec_pool, pspec->name, g_type, FALSE)) ------------------ | | 814| 1|#define FALSE (0) ------------------ | Branch (570:7): [True: 0, False: 1] ------------------ 571| 0| { 572| 0| g_warning ("When installing property: type '%s' already has a property named '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 573| 0| g_type_name (g_type), 574| 0| pspec->name); 575| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 576| 0| } 577| | 578| 1| g_param_spec_ref_sink (pspec); 579| 1| PARAM_SPEC_SET_PARAM_ID (pspec, property_id); ------------------ | | 134| 1|#define PARAM_SPEC_SET_PARAM_ID(pspec, id) ((pspec)->param_id = (id)) ------------------ 580| 1| g_param_spec_pool_insert (pspec_pool, pspec, g_type); 581| 1| return TRUE; ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 582| 1|} gobject.c:object_get_optional_flags: 1036| 11.5k|{ 1037| 11.5k|#ifdef HAVE_OPTIONAL_FLAGS 1038| 11.5k| GObjectReal *real = (GObjectReal *)object; 1039| 11.5k| return (guint)g_atomic_int_get (&real->optional_flags); ------------------ | | 96| 11.5k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 11.5k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 11.5k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 11.5k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 11.5k| gint gaig_temp; \ | | 99| 11.5k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 11.5k] | | ------------------ | | 100| 11.5k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 11.5k| (gint) gaig_temp; \ | | 102| 11.5k| })) ------------------ 1040| |#else 1041| | return 0; 1042| |#endif 1043| 11.5k|} gobject.c:g_object_init: 1116| 7.70k|{ 1117| 7.70k| object->ref_count = 1; 1118| 7.70k| object->qdata = NULL; 1119| | 1120| 7.70k| if (CLASS_HAS_PROPS (class)) ------------------ | | 143| 7.70k| ((class)->flags & CLASS_HAS_PROPS_FLAG) | | ------------------ | | | | 141| 7.70k|#define CLASS_HAS_PROPS_FLAG 0x1 | | ------------------ | | | Branch (143:5): [True: 3.85k, False: 3.85k] | | ------------------ ------------------ 1121| 3.85k| { 1122| | /* freeze object's notification queue, g_object_newv() preserves pairedness */ 1123| 3.85k| g_object_notify_queue_freeze (object, FALSE); ------------------ | | 814| 3.85k|#define FALSE (0) ------------------ 1124| 3.85k| } 1125| | 1126| 7.70k| if (CLASS_HAS_CUSTOM_CONSTRUCTOR (class)) ------------------ | | 145| 7.70k| ((class)->constructor != g_object_constructor) | | ------------------ | | | Branch (145:5): [True: 0, False: 7.70k] | | ------------------ ------------------ 1127| 0| { 1128| | /* mark object in-construction for notify_queue_thaw() and to allow construct-only properties */ 1129| 0| set_object_in_construction (object); 1130| 0| } 1131| | 1132| 7.70k| GOBJECT_IF_DEBUG (OBJECTS, ------------------ | | 37| 7.70k|#define GOBJECT_IF_DEBUG(debug_type, code_block) \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 38| 7.70k|G_STMT_START { \ | | 39| 7.70k| if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type) \ | | ------------------ | | | Branch (39:9): [True: 0, False: 7.70k] | | ------------------ | | 40| 7.70k| { code_block; } \ | | 41| 7.70k|} G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 1133| 7.70k| { 1134| 7.70k| G_LOCK (debug_objects); 1135| 7.70k| debug_objects_count++; 1136| 7.70k| g_hash_table_add (debug_objects_ht, object); 1137| 7.70k| G_UNLOCK (debug_objects); 1138| 7.70k| }); 1139| 7.70k|} gobject.c:g_object_notify_queue_freeze: 274| 3.85k|{ 275| 3.85k| GObjectNotifyQueue *nqueue; 276| | 277| 3.85k| G_LOCK(notify_lock); ------------------ | | 135| 3.85k|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 278| 3.85k| nqueue = g_datalist_id_get_data (&object->qdata, quark_notify_queue); 279| 3.85k| if (!nqueue) ------------------ | Branch (279:7): [True: 3.85k, False: 0] ------------------ 280| 3.85k| { 281| 3.85k| if (conditional) ------------------ | Branch (281:11): [True: 0, False: 3.85k] ------------------ 282| 0| { 283| 0| G_UNLOCK(notify_lock); ------------------ | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 284| 0| return NULL; 285| 0| } 286| | 287| 3.85k| nqueue = g_slice_new0 (GObjectNotifyQueue); ------------------ | | 52| 3.85k| (type *) (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 53| 3.85k| gsize __s = sizeof (type); \ | | 54| 3.85k| gpointer __p; \ | | 55| 3.85k| __p = g_slice_alloc (__s); \ | | 56| 3.85k| memset (__p, 0, __s); \ | | 57| 3.85k| __p; \ | | 58| 3.85k| })) ------------------ 288| 3.85k| g_datalist_id_set_data_full (&object->qdata, quark_notify_queue, 289| 3.85k| nqueue, g_object_notify_queue_free); 290| 3.85k| } 291| | 292| 3.85k| if (nqueue->freeze_count >= 65535) ------------------ | Branch (292:7): [True: 0, False: 3.85k] ------------------ 293| 0| g_critical("Free queue for %s (%p) is larger than 65535," ------------------ | | 342| 0|#define g_critical(...) g_log (G_LOG_DOMAIN, \ | | 343| 0| G_LOG_LEVEL_CRITICAL, \ | | 344| 0| __VA_ARGS__) ------------------ 294| 3.85k| " called g_object_freeze_notify() too often." 295| 3.85k| " Forgot to call g_object_thaw_notify() or infinite loop", 296| 3.85k| G_OBJECT_TYPE_NAME (object), object); 297| 3.85k| else 298| 3.85k| nqueue->freeze_count++; 299| 3.85k| G_UNLOCK(notify_lock); ------------------ | | 136| 3.85k|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 300| | 301| 3.85k| return nqueue; 302| 3.85k|} gobject.c:g_object_notify_queue_free: 264| 3.85k|{ 265| 3.85k| GObjectNotifyQueue *nqueue = data; 266| | 267| 3.85k| g_slist_free (nqueue->pspecs); 268| 3.85k| g_slice_free (GObjectNotifyQueue, nqueue); ------------------ | | 79| 3.85k|#define g_slice_free(type, mem) \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 80| 3.85k|G_STMT_START { \ | | 81| 3.85k| if (1) g_slice_free1 (sizeof (type), (mem)); \ | | ------------------ | | | Branch (81:7): [True: 3.85k, Folded] | | ------------------ | | 82| 3.85k| else (void) ((type*) 0 == (mem)); \ | | 83| 3.85k|} G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 269| 3.85k|} gobject.c:get_notify_pspec: 1260| 3.85k|{ 1261| 3.85k| GParamSpec *redirected; 1262| | 1263| | /* we don't notify on non-READABLE parameters */ 1264| 3.85k| if (~pspec->flags & G_PARAM_READABLE) ------------------ | Branch (1264:7): [True: 0, False: 3.85k] ------------------ 1265| 0| return NULL; 1266| | 1267| | /* if the paramspec is redirected, notify on the target */ 1268| 3.85k| redirected = g_param_spec_get_redirect_target (pspec); 1269| 3.85k| if (redirected != NULL) ------------------ | Branch (1269:7): [True: 0, False: 3.85k] ------------------ 1270| 0| return redirected; 1271| | 1272| | /* else, notify normally */ 1273| 3.85k| return pspec; 1274| 3.85k|} gobject.c:g_object_notify_queue_add: 349| 3.85k|{ 350| 3.85k| G_LOCK(notify_lock); ------------------ | | 135| 3.85k|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 351| | 352| 3.85k| g_assert (nqueue->n_pspecs < 65535); ------------------ | | 231| 3.85k|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 232| 3.85k| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 233| 3.85k| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 353| | 354| 3.85k| if (g_slist_find (nqueue->pspecs, pspec) == NULL) ------------------ | Branch (354:7): [True: 3.85k, False: 0] ------------------ 355| 3.85k| { 356| 3.85k| nqueue->pspecs = g_slist_prepend (nqueue->pspecs, pspec); 357| 3.85k| nqueue->n_pspecs++; 358| 3.85k| } 359| | 360| 3.85k| G_UNLOCK(notify_lock); ------------------ | | 136| 3.85k|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 361| 3.85k|} gobject.c:g_object_notify_queue_thaw: 307| 3.85k|{ 308| 3.85k| GParamSpec *pspecs_mem[16], **pspecs, **free_me = NULL; 309| 3.85k| GSList *slist; 310| 3.85k| guint n_pspecs = 0; 311| | 312| 3.85k| g_return_if_fail (g_atomic_int_get(&object->ref_count) > 0); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 11.5k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [Folded, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 313| | 314| 3.85k| G_LOCK(notify_lock); ------------------ | | 135| 3.85k|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 315| | 316| | /* Just make sure we never get into some nasty race condition */ 317| 3.85k| if (G_UNLIKELY(nqueue->freeze_count == 0)) { ------------------ | | 1025| 3.85k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | 1018| 3.85k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | ------------------ | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | 1020| 3.85k| else \ | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | 1023| 3.85k|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 3.85k] | | ------------------ ------------------ 318| 0| G_UNLOCK(notify_lock); ------------------ | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 319| 0| g_warning ("%s: property-changed notification for %s(%p) is not frozen", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 320| 0| G_STRFUNC, G_OBJECT_TYPE_NAME (object), object); 321| 0| return; 322| 0| } 323| | 324| 3.85k| nqueue->freeze_count--; 325| 3.85k| if (nqueue->freeze_count) { ------------------ | Branch (325:7): [True: 0, False: 3.85k] ------------------ 326| 0| G_UNLOCK(notify_lock); ------------------ | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 327| 0| return; 328| 0| } 329| | 330| 3.85k| pspecs = nqueue->n_pspecs > 16 ? free_me = g_new (GParamSpec*, nqueue->n_pspecs) : pspecs_mem; ------------------ | | 290| 0|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 0| gsize __n = (gsize) (n_structs); \ | | | | 237| 0| gsize __s = sizeof (struct_type); \ | | | | 238| 0| gpointer __p; \ | | | | 239| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 0] | | | | ------------------ | | | | 240| 0| __p = g_##func (__n); \ | | | | 241| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 0| __p; \ | | | | 247| 0| })) | | ------------------ ------------------ | Branch (330:12): [True: 0, False: 3.85k] ------------------ 331| | 332| 7.70k| for (slist = nqueue->pspecs; slist; slist = slist->next) ------------------ | Branch (332:32): [True: 3.85k, False: 3.85k] ------------------ 333| 3.85k| { 334| 3.85k| pspecs[n_pspecs++] = slist->data; 335| 3.85k| } 336| 3.85k| g_datalist_id_set_data (&object->qdata, quark_notify_queue, NULL); ------------------ | | 99| 3.85k| g_datalist_id_set_data_full ((dl), (q), (d), NULL) ------------------ 337| | 338| 3.85k| G_UNLOCK(notify_lock); ------------------ | | 136| 3.85k|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | ------------------ | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | ------------------ ------------------ 339| | 340| 3.85k| if (n_pspecs) ------------------ | Branch (340:7): [True: 3.85k, False: 0] ------------------ 341| 3.85k| G_OBJECT_GET_CLASS (object)->dispatch_properties_changed (object, n_pspecs, pspecs); ------------------ | | 91| 3.85k|#define G_OBJECT_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass)) | | ------------------ | | | | 527| 3.85k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 3.85k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ 342| 3.85k| g_free (free_me); 343| 3.85k|} gobject.c:g_object_new_internal: 1932| 7.70k|{ 1933| 7.70k| GObjectNotifyQueue *nqueue = NULL; 1934| 7.70k| GObject *object; 1935| | 1936| 7.70k| if G_UNLIKELY (CLASS_HAS_CUSTOM_CONSTRUCTOR (class)) ------------------ | | 1025| 7.70k|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | 1018| 7.70k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 7.70k] | | | | ------------------ | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | 1020| 7.70k| else \ | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | 1023| 7.70k|}) | | ------------------ | | | Branch (1025:27): [True: 0, False: 7.70k] | | ------------------ ------------------ 1937| 0| return g_object_new_with_custom_constructor (class, params, n_params); 1938| | 1939| 7.70k| object = (GObject *) g_type_create_instance (class->g_type_class.g_type); 1940| | 1941| 7.70k| if (CLASS_HAS_PROPS (class)) ------------------ | | 143| 7.70k| ((class)->flags & CLASS_HAS_PROPS_FLAG) | | ------------------ | | | | 141| 7.70k|#define CLASS_HAS_PROPS_FLAG 0x1 | | ------------------ | | | Branch (143:5): [True: 3.85k, False: 3.85k] | | ------------------ ------------------ 1942| 3.85k| { 1943| 3.85k| GSList *node; 1944| | 1945| | /* This will have been setup in g_object_init() */ 1946| 3.85k| nqueue = g_datalist_id_get_data (&object->qdata, quark_notify_queue); 1947| 3.85k| g_assert (nqueue != NULL); ------------------ | | 231| 3.85k|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 232| 3.85k| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 233| 3.85k| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 1948| | 1949| | /* We will set exactly n_construct_properties construct 1950| | * properties, but they may come from either the class default 1951| | * values or the passed-in parameter list. 1952| | */ 1953| 7.70k| for (node = class->construct_properties; node; node = node->next) ------------------ | Branch (1953:48): [True: 3.85k, False: 3.85k] ------------------ 1954| 3.85k| { 1955| 3.85k| const GValue *value; 1956| 3.85k| GParamSpec *pspec; 1957| 3.85k| guint j; 1958| | 1959| 3.85k| pspec = node->data; 1960| 3.85k| value = NULL; /* to silence gcc... */ 1961| | 1962| 3.85k| for (j = 0; j < n_params; j++) ------------------ | Branch (1962:23): [True: 0, False: 3.85k] ------------------ 1963| 0| if (params[j].pspec == pspec) ------------------ | Branch (1963:17): [True: 0, False: 0] ------------------ 1964| 0| { 1965| 0| consider_issuing_property_deprecation_warning (pspec); 1966| 0| value = params[j].value; 1967| 0| break; 1968| 0| } 1969| | 1970| 3.85k| if (value == NULL) ------------------ | Branch (1970:15): [True: 3.85k, False: 0] ------------------ 1971| 3.85k| value = g_param_spec_get_default_value (pspec); 1972| | 1973| 3.85k| object_set_property (object, pspec, value, nqueue); 1974| 3.85k| } 1975| 3.85k| } 1976| | 1977| | /* run 'constructed' handler if there is a custom one */ 1978| 7.70k| if (CLASS_HAS_CUSTOM_CONSTRUCTED (class)) ------------------ | | 147| 7.70k| ((class)->constructed != g_object_constructed) | | ------------------ | | | Branch (147:5): [True: 3.85k, False: 3.85k] | | ------------------ ------------------ 1979| 3.85k| class->constructed (object); 1980| | 1981| 7.70k| if (nqueue) ------------------ | Branch (1981:7): [True: 3.85k, False: 3.85k] ------------------ 1982| 3.85k| { 1983| 3.85k| guint i; 1984| | 1985| | /* Set remaining properties. The construct properties will 1986| | * already have been taken, so set only the non-construct 1987| | * ones. 1988| | */ 1989| 3.85k| for (i = 0; i < n_params; i++) ------------------ | Branch (1989:19): [True: 0, False: 3.85k] ------------------ 1990| 0| if (!(params[i].pspec->flags & (G_PARAM_CONSTRUCT | G_PARAM_CONSTRUCT_ONLY))) ------------------ | Branch (1990:13): [True: 0, False: 0] ------------------ 1991| 0| { 1992| 0| consider_issuing_property_deprecation_warning (params[i].pspec); 1993| 0| object_set_property (object, params[i].pspec, params[i].value, nqueue); 1994| 0| } 1995| | 1996| 3.85k| g_object_notify_queue_thaw (object, nqueue); 1997| 3.85k| } 1998| | 1999| 7.70k| return object; 2000| 7.70k|} gobject.c:object_set_property: 1528| 3.85k|{ 1529| 3.85k| GValue tmp_value = G_VALUE_INIT; ------------------ | | 202| 3.85k|#define G_VALUE_INIT { 0, { { 0 } } } ------------------ 1530| 3.85k| GObjectClass *class = g_type_class_peek (pspec->owner_type); 1531| 3.85k| guint param_id = PARAM_SPEC_PARAM_ID (pspec); ------------------ | | 133| 3.85k|#define PARAM_SPEC_PARAM_ID(pspec) ((pspec)->param_id) ------------------ 1532| 3.85k| GParamSpec *redirect; 1533| | 1534| 3.85k| if (class == NULL) ------------------ | Branch (1534:7): [True: 0, False: 3.85k] ------------------ 1535| 0| { 1536| 0| g_warning ("'%s::%s' is not a valid property name; '%s' is not a GObject subtype", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1537| 0| g_type_name (pspec->owner_type), pspec->name, g_type_name (pspec->owner_type)); 1538| 0| return; 1539| 0| } 1540| | 1541| 3.85k| redirect = g_param_spec_get_redirect_target (pspec); 1542| 3.85k| if (redirect) ------------------ | Branch (1542:7): [True: 0, False: 3.85k] ------------------ 1543| 0| pspec = redirect; 1544| | 1545| | /* provide a copy to work from, convert (if necessary) and validate */ 1546| 3.85k| g_value_init (&tmp_value, pspec->value_type); 1547| 3.85k| if (!g_value_transform (value, &tmp_value)) ------------------ | Branch (1547:7): [True: 0, False: 3.85k] ------------------ 1548| 0| g_warning ("unable to set property '%s' of type '%s' from value of type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1549| 3.85k| pspec->name, 1550| 3.85k| g_type_name (pspec->value_type), 1551| 3.85k| G_VALUE_TYPE_NAME (value)); 1552| 3.85k| else if (g_param_value_validate (pspec, &tmp_value) && !(pspec->flags & G_PARAM_LAX_VALIDATION)) ------------------ | Branch (1552:12): [True: 0, False: 3.85k] | Branch (1552:58): [True: 0, False: 0] ------------------ 1553| 0| { 1554| 0| gchar *contents = g_strdup_value_contents (value); 1555| | 1556| 0| g_warning ("value \"%s\" of type '%s' is invalid or out of range for property '%s' of type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1557| 0| contents, 1558| 0| G_VALUE_TYPE_NAME (value), 1559| 0| pspec->name, 1560| 0| g_type_name (pspec->value_type)); 1561| 0| g_free (contents); 1562| 0| } 1563| 3.85k| else 1564| 3.85k| { 1565| 3.85k| class->set_property (object, param_id, &tmp_value, pspec); 1566| | 1567| 3.85k| if (~pspec->flags & G_PARAM_EXPLICIT_NOTIFY) ------------------ | Branch (1567:11): [True: 3.85k, False: 0] ------------------ 1568| 3.85k| { 1569| 3.85k| GParamSpec *notify_pspec; 1570| | 1571| 3.85k| notify_pspec = get_notify_pspec (pspec); 1572| | 1573| 3.85k| if (notify_pspec != NULL) ------------------ | Branch (1573:15): [True: 3.85k, False: 0] ------------------ 1574| 3.85k| g_object_notify_queue_add (object, nqueue, notify_pspec); 1575| 3.85k| } 1576| 3.85k| } 1577| 3.85k| g_value_unset (&tmp_value); 1578| 3.85k|} gobject.c:g_value_object_init: 3972| 3.85k|{ 3973| | value->data[0].v_pointer = NULL; 3974| 3.85k|} gobject.c:g_value_object_free_value: 3978| 7.70k|{ 3979| 7.70k| if (value->data[0].v_pointer) ------------------ | Branch (3979:7): [True: 0, False: 7.70k] ------------------ 3980| 0| g_object_unref (value->data[0].v_pointer); 3981| 7.70k|} gobject.c:g_value_object_copy_value: 3986| 3.85k|{ 3987| 3.85k| if (src_value->data[0].v_pointer) ------------------ | Branch (3987:7): [True: 0, False: 3.85k] ------------------ 3988| 0| dest_value->data[0].v_pointer = g_object_ref (src_value->data[0].v_pointer); ------------------ | | 523| 0|#define g_object_ref(Obj) ((glib_typeof (Obj)) (g_object_ref) (Obj)) ------------------ 3989| 3.85k| else 3990| 3.85k| dest_value->data[0].v_pointer = NULL; 3991| 3.85k|} _g_param_type_init: 101| 2|{ 102| 2| static const GTypeFundamentalInfo finfo = { 103| 2| (G_TYPE_FLAG_CLASSED | 104| 2| G_TYPE_FLAG_INSTANTIATABLE | 105| 2| G_TYPE_FLAG_DERIVABLE | 106| 2| G_TYPE_FLAG_DEEP_DERIVABLE), 107| 2| }; 108| 2| static const GTypeValueTable param_value_table = { 109| 2| value_param_init, /* value_init */ 110| 2| value_param_free_value, /* value_free */ 111| 2| value_param_copy_value, /* value_copy */ 112| 2| value_param_peek_pointer, /* value_peek_pointer */ 113| 2| "p", /* collect_format */ 114| 2| value_param_collect_value, /* collect_value */ 115| 2| "p", /* lcopy_format */ 116| 2| value_param_lcopy_value, /* lcopy_value */ 117| 2| }; 118| 2| const GTypeInfo param_spec_info = { 119| 2| sizeof (GParamSpecClass), 120| | 121| 2| (GBaseInitFunc) g_param_spec_class_base_init, 122| 2| (GBaseFinalizeFunc) g_param_spec_class_base_finalize, 123| 2| (GClassInitFunc) g_param_spec_class_init, 124| 2| (GClassFinalizeFunc) NULL, 125| 2| NULL, /* class_data */ 126| | 127| 2| sizeof (GParamSpec), 128| 2| 0, /* n_preallocs */ 129| 2| (GInstanceInitFunc) g_param_spec_init, 130| | 131| 2| ¶m_value_table, 132| 2| }; 133| 2| GType type; 134| | 135| | /* This should be registered as GParamSpec instead of GParam, for 136| | * consistency sake, so that type name can be mapped to struct name, 137| | * However, some language bindings, most noticeable the python ones 138| | * depends on the "GParam" identifier, see #548689 139| | */ 140| 2| type = g_type_register_fundamental (G_TYPE_PARAM, g_intern_static_string ("GParam"), ¶m_spec_info, &finfo, G_TYPE_FLAG_ABSTRACT); ------------------ | | 172| 2|#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 141| 2| g_assert (type == G_TYPE_PARAM); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 142| 2| g_param_private_offset = g_type_add_instance_private (type, sizeof (GParamSpecPrivate)); 143| 2| g_value_register_transform_func (G_TYPE_PARAM, G_TYPE_PARAM, value_param_transform_value); ------------------ | | 172| 2|#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_PARAM, G_TYPE_PARAM, value_param_transform_value); ------------------ | | 172| 2|#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 144| 2|} g_param_spec_ref: 214| 1|{ 215| 1| g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 216| | 217| 1| g_atomic_int_inc ((int *)&pspec->ref_count); ------------------ | | 148| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 149| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 150| 1| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (150:13): [Folded, False: 1] | | ------------------ | | 151| 1| (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ | | 152| 1| })) ------------------ 218| | 219| 1| return pspec; 220| 1|} g_param_spec_ref_sink: 277| 1|{ 278| 1| gsize oldvalue; 279| 1| g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 280| | 281| 1| oldvalue = g_atomic_pointer_and (&pspec->qdata, ~(gsize)PARAM_FLOATING_FLAG); ------------------ | | 226| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 227| 1| gsize *gapa_atomic = (gsize *) (atomic); \ | | 228| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 229| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gsize)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 230| 1| (void) (0 ? (gpointer) *(atomic) : NULL); \ | | ------------------ | | | Branch (230:13): [Folded, False: 1] | | ------------------ | | 231| 1| (void) (0 ? (val) ^ (val) : 1); \ | | ------------------ | | | Branch (231:13): [Folded, False: 1] | | ------------------ | | 232| 1| (gsize) __atomic_fetch_and (gapa_atomic, (val), __ATOMIC_SEQ_CST); \ | | 233| 1| })) ------------------ 282| 1| if (!(oldvalue & PARAM_FLOATING_FLAG)) ------------------ | | 56| 1|#define PARAM_FLOATING_FLAG 0x2 ------------------ | Branch (282:7): [True: 0, False: 1] ------------------ 283| 0| g_param_spec_ref (pspec); 284| | 285| 1| return pspec; 286| 1|} g_param_spec_is_valid_name: 400| 2|{ 401| 2| const gchar *p; 402| | 403| | /* First character must be a letter. */ 404| 2| if ((name[0] < 'A' || name[0] > 'Z') && ------------------ | Branch (404:8): [True: 0, False: 2] | Branch (404:25): [True: 2, False: 0] ------------------ 405| 2| (name[0] < 'a' || name[0] > 'z')) ------------------ | Branch (405:8): [True: 0, False: 2] | Branch (405:25): [True: 0, False: 2] ------------------ 406| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 407| | 408| 14| for (p = name; *p != 0; p++) ------------------ | Branch (408:18): [True: 12, False: 2] ------------------ 409| 12| { 410| 12| const gchar c = *p; 411| | 412| 12| if (c != '-' && c != '_' && ------------------ | Branch (412:11): [True: 12, False: 0] | Branch (412:23): [True: 12, False: 0] ------------------ 413| 12| (c < '0' || c > '9') && ------------------ | Branch (413:12): [True: 0, False: 12] | Branch (413:23): [True: 12, False: 0] ------------------ 414| 12| (c < 'A' || c > 'Z') && ------------------ | Branch (414:12): [True: 0, False: 12] | Branch (414:23): [True: 12, False: 0] ------------------ 415| 12| (c < 'a' || c > 'z')) ------------------ | Branch (415:12): [True: 0, False: 12] | Branch (415:23): [True: 0, False: 12] ------------------ 416| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 417| 12| } 418| | 419| 2| return TRUE; ------------------ | | 818| 2|#define TRUE (!FALSE) | | ------------------ | | | | 814| 2|#define FALSE (0) | | ------------------ ------------------ 420| 2|} g_param_spec_internal: 451| 1|{ 452| 1| GParamSpec *pspec; 453| 1| GParamSpecPrivate *priv; 454| | 455| 1| g_return_val_if_fail (G_TYPE_IS_PARAM (param_type) && param_type != G_TYPE_PARAM, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 456| 1| g_return_val_if_fail (name != NULL, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 457| 1| g_return_val_if_fail (g_param_spec_is_valid_name (name), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 458| 1| g_return_val_if_fail (!(flags & G_PARAM_STATIC_NAME) || is_canonical (name), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 1] | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 459| | 460| 1| pspec = (gpointer) g_type_create_instance (param_type); 461| | 462| 1| if (flags & G_PARAM_STATIC_NAME) ------------------ | Branch (462:7): [True: 1, False: 0] ------------------ 463| 1| { 464| | /* pspec->name is not freed if (flags & G_PARAM_STATIC_NAME) */ 465| 1| pspec->name = (gchar *) g_intern_static_string (name); 466| 1| if (!is_canonical (pspec->name)) ------------------ | Branch (466:11): [True: 0, False: 1] ------------------ 467| 0| g_warning ("G_PARAM_STATIC_NAME used with non-canonical pspec name: %s", pspec->name); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 468| 1| } 469| 0| else 470| 0| { 471| 0| if (is_canonical (name)) ------------------ | Branch (471:11): [True: 0, False: 0] ------------------ 472| 0| pspec->name = (gchar *) g_intern_string (name); 473| 0| else 474| 0| { 475| 0| gchar *tmp = g_strdup (name); 476| 0| canonicalize_key (tmp); 477| 0| pspec->name = (gchar *) g_intern_string (tmp); 478| 0| g_free (tmp); 479| 0| } 480| 0| } 481| | 482| 1| priv = g_param_spec_get_private (pspec); 483| 1| priv->name_quark = g_quark_from_string (pspec->name); 484| | 485| 1| if (flags & G_PARAM_STATIC_NICK) ------------------ | Branch (485:7): [True: 0, False: 1] ------------------ 486| 0| pspec->_nick = (gchar*) nick; 487| 1| else 488| 1| pspec->_nick = g_strdup (nick); 489| | 490| 1| if (flags & G_PARAM_STATIC_BLURB) ------------------ | Branch (490:7): [True: 0, False: 1] ------------------ 491| 0| pspec->_blurb = (gchar*) blurb; 492| 1| else 493| 1| pspec->_blurb = g_strdup (blurb); 494| | 495| 1| pspec->flags = (flags & G_PARAM_USER_MASK) | (flags & G_PARAM_MASK); ------------------ | | 57| 1|#define G_PARAM_USER_MASK (~0U << G_PARAM_USER_SHIFT) | | ------------------ | | | | 189| 1|#define G_PARAM_USER_SHIFT (8) | | ------------------ ------------------ pspec->flags = (flags & G_PARAM_USER_MASK) | (flags & G_PARAM_MASK); ------------------ | | 182| 1|#define G_PARAM_MASK (0x000000ff) ------------------ 496| | 497| 1| return pspec; 498| 1|} g_param_spec_get_redirect_target: 609| 7.70k|{ 610| 7.70k| GTypeInstance *inst = (GTypeInstance *)pspec; 611| | 612| 7.70k| if (inst && inst->g_class && inst->g_class->g_type == G_TYPE_PARAM_OVERRIDE) ------------------ | | 507| 7.70k|#define G_TYPE_PARAM_OVERRIDE (g_param_spec_types[20]) ------------------ | Branch (612:7): [True: 7.70k, False: 0] | Branch (612:15): [True: 7.70k, False: 0] | Branch (612:32): [True: 0, False: 7.70k] ------------------ 613| 0| return ((GParamSpecOverride*)pspec)->overridden; 614| 7.70k| else 615| 7.70k| return NULL; 616| 7.70k|} g_param_value_set_default: 629| 1|{ 630| 1| g_return_if_fail (G_IS_PARAM_SPEC (pspec)); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 631| | 632| 1| if (G_VALUE_TYPE (value) == G_TYPE_INVALID) ------------------ | | 59| 1|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ if (G_VALUE_TYPE (value) == G_TYPE_INVALID) ------------------ | | 55| 1|#define G_TYPE_INVALID G_TYPE_MAKE_FUNDAMENTAL (0) | | ------------------ | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (632:7): [True: 0, False: 1] ------------------ 633| 0| { 634| 0| g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec)); ------------------ | | 103| 0|#define G_PARAM_SPEC_VALUE_TYPE(pspec) (G_PARAM_SPEC (pspec)->value_type) | | ------------------ | | | | 45| 0|#define G_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM, GParamSpec)) | | | | ------------------ | | | | | | 484| 0|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | | | ------------------ | | | | | | | | 2300| 0| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 635| 0| } 636| 1| else 637| 1| { 638| 1| g_return_if_fail (G_IS_VALUE (value)); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 639| 1| g_return_if_fail (PSPEC_APPLIES_TO_VALUE (pspec, value)); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 5| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 1] | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 640| 1| g_value_reset (value); 641| 1| } 642| | 643| 1| G_PARAM_SPEC_GET_CLASS (pspec)->value_set_default (pspec, value); ------------------ | | 79| 1|#define G_PARAM_SPEC_GET_CLASS(pspec) (G_TYPE_INSTANCE_GET_CLASS ((pspec), G_TYPE_PARAM, GParamSpecClass)) | | ------------------ | | | | 527| 1|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 1|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ 644| 1|} g_param_value_validate: 691| 3.85k|{ 692| 3.85k| g_return_val_if_fail (G_IS_PARAM_SPEC (pspec), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 693| 3.85k| g_return_val_if_fail (G_IS_VALUE (value), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 694| 3.85k| g_return_val_if_fail (PSPEC_APPLIES_TO_VALUE (pspec, value), FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 19.2k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 3.85k] | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 695| | 696| 3.85k| if (G_PARAM_SPEC_GET_CLASS (pspec)->value_validate) ------------------ | | 79| 3.85k|#define G_PARAM_SPEC_GET_CLASS(pspec) (G_TYPE_INSTANCE_GET_CLASS ((pspec), G_TYPE_PARAM, GParamSpecClass)) | | ------------------ | | | | 527| 3.85k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 3.85k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ | Branch (696:7): [True: 3.85k, False: 0] ------------------ 697| 3.85k| { 698| 3.85k| GValue oval = *value; 699| | 700| 3.85k| if (G_PARAM_SPEC_GET_CLASS (pspec)->value_validate (pspec, value) || ------------------ | | 79| 3.85k|#define G_PARAM_SPEC_GET_CLASS(pspec) (G_TYPE_INSTANCE_GET_CLASS ((pspec), G_TYPE_PARAM, GParamSpecClass)) | | ------------------ | | | | 527| 3.85k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2309| 3.85k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | | | ------------------ | | ------------------ ------------------ | Branch (700:11): [True: 0, False: 3.85k] ------------------ 701| 3.85k| memcmp (&oval.data, &value->data, sizeof (oval.data))) ------------------ | Branch (701:4): [True: 0, False: 3.85k] ------------------ 702| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 703| 3.85k| } 704| | 705| 3.85k| return FALSE; ------------------ | | 814| 3.85k|#define FALSE (0) ------------------ 706| 3.85k|} g_param_spec_pool_new: 943| 1|{ 944| 1| static GMutex init_mutex; 945| 1| GParamSpecPool *pool = g_new (GParamSpecPool, 1); ------------------ | | 290| 1|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 1| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 1| gsize __n = (gsize) (n_structs); \ | | | | 237| 1| gsize __s = sizeof (struct_type); \ | | | | 238| 1| gpointer __p; \ | | | | 239| 1| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 1] | | | | ------------------ | | | | 240| 1| __p = g_##func (__n); \ | | | | 241| 1| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 1, False: 0] | | | | ------------------ | | | | 242| 1| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 1|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 1|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 1] | | | | | Branch (242:26): [True: 1, False: 0] | | | | ------------------ | | | | 243| 1| __p = g_##func (__n * __s); \ | | | | 244| 1| else \ | | | | 245| 1| __p = g_##func##_n (__n, __s); \ | | | | 246| 1| __p; \ | | | | 247| 1| })) | | ------------------ ------------------ 946| | 947| 1| memcpy (&pool->mutex, &init_mutex, sizeof (init_mutex)); 948| 1| pool->type_prefixing = type_prefixing != FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 949| 1| pool->hash_table = g_hash_table_new (param_spec_pool_hash, param_spec_pool_equals); 950| | 951| 1| return pool; 952| 1|} g_param_spec_pool_insert: 966| 1|{ 967| 1| const gchar *p; 968| | 969| 1| if (pool && pspec && owner_type > 0 && pspec->owner_type == 0) ------------------ | Branch (969:7): [True: 1, False: 0] | Branch (969:15): [True: 1, False: 0] | Branch (969:24): [True: 1, False: 0] | Branch (969:42): [True: 1, False: 0] ------------------ 970| 1| { 971| 7| for (p = pspec->name; *p; p++) ------------------ | Branch (971:29): [True: 6, False: 1] ------------------ 972| 6| { 973| 6| if (!strchr (G_CSET_A_2_Z G_CSET_a_2_z G_CSET_DIGITS "-_", *p)) ------------------ | | 49| 6|#define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ------------------ | Branch (973:8): [True: 0, False: 6] ------------------ 974| 0| { 975| 0| g_warning (G_STRLOC ": pspec name \"%s\" contains invalid characters", pspec->name); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 976| 0| return; 977| 0| } 978| 6| } 979| 1| g_mutex_lock (&pool->mutex); 980| 1| pspec->owner_type = owner_type; 981| 1| g_param_spec_ref (pspec); 982| 1| g_hash_table_add (pool->hash_table, pspec); 983| 1| g_mutex_unlock (&pool->mutex); 984| 1| } 985| 0| else 986| 0| { 987| 0| g_return_if_fail (pool != NULL); ------------------ | | 630| 0| G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 631| 0| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 632| 0| { } \ | | 633| 0| else \ | | 634| 0| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 988| 0| g_return_if_fail (pspec); ------------------ | | 630| 0| G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 631| 0| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 632| 0| { } \ | | 633| 0| else \ | | 634| 0| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 989| 0| g_return_if_fail (owner_type > 0); ------------------ | | 630| 0| G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 631| 0| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 632| 0| { } \ | | 633| 0| else \ | | 634| 0| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 990| 0| g_return_if_fail (pspec->owner_type == 0); ------------------ | | 630| 0| G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 631| 0| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 632| 0| { } \ | | 633| 0| else \ | | 634| 0| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 991| 0| } 992| 1|} g_param_spec_pool_lookup: 1093| 2|{ 1094| 2| GParamSpec *pspec; 1095| 2| gchar *delim; 1096| | 1097| 2| g_return_val_if_fail (pool != NULL, NULL); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1098| 2| g_return_val_if_fail (param_name != NULL, NULL); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1099| | 1100| 2| g_mutex_lock (&pool->mutex); 1101| | 1102| 2| delim = pool->type_prefixing ? strchr (param_name, ':') : NULL; ------------------ | Branch (1102:11): [True: 2, False: 0] ------------------ 1103| | 1104| | /* try quick and away, i.e. without prefix */ 1105| 2| if (!delim) ------------------ | Branch (1105:7): [True: 2, False: 0] ------------------ 1106| 2| { 1107| 2| pspec = param_spec_ht_lookup (pool->hash_table, param_name, owner_type, walk_ancestors); 1108| 2| g_mutex_unlock (&pool->mutex); 1109| | 1110| 2| return pspec; 1111| 2| } 1112| | 1113| | /* strip type prefix */ 1114| 0| if (pool->type_prefixing && delim[1] == ':') ------------------ | Branch (1114:7): [True: 0, False: 0] | Branch (1114:31): [True: 0, False: 0] ------------------ 1115| 0| { 1116| 0| guint l = delim - param_name; 1117| 0| gchar stack_buffer[32], *buffer = l < 32 ? stack_buffer : g_new (gchar, l + 1); ------------------ | | 290| 0|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 0| gsize __n = (gsize) (n_structs); \ | | | | 237| 0| gsize __s = sizeof (struct_type); \ | | | | 238| 0| gpointer __p; \ | | | | 239| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 0] | | | | ------------------ | | | | 240| 0| __p = g_##func (__n); \ | | | | 241| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 0| __p; \ | | | | 247| 0| })) | | ------------------ ------------------ | Branch (1117:41): [True: 0, False: 0] ------------------ 1118| 0| GType type; 1119| | 1120| 0| strncpy (buffer, param_name, delim - param_name); 1121| 0| buffer[l] = 0; 1122| 0| type = g_type_from_name (buffer); 1123| 0| if (l >= 32) ------------------ | Branch (1123:11): [True: 0, False: 0] ------------------ 1124| 0| g_free (buffer); 1125| 0| if (type) /* type==0 isn't a valid type pefix */ ------------------ | Branch (1125:11): [True: 0, False: 0] ------------------ 1126| 0| { 1127| | /* sanity check, these cases don't make a whole lot of sense */ 1128| 0| if ((!walk_ancestors && type != owner_type) || !g_type_is_a (owner_type, type)) ------------------ | Branch (1128:9): [True: 0, False: 0] | Branch (1128:28): [True: 0, False: 0] | Branch (1128:51): [True: 0, False: 0] ------------------ 1129| 0| { 1130| 0| g_mutex_unlock (&pool->mutex); 1131| | 1132| 0| return NULL; 1133| 0| } 1134| 0| owner_type = type; 1135| 0| param_name += l + 2; 1136| 0| pspec = param_spec_ht_lookup (pool->hash_table, param_name, owner_type, walk_ancestors); 1137| 0| g_mutex_unlock (&pool->mutex); 1138| | 1139| 0| return pspec; 1140| 0| } 1141| 0| } 1142| | /* malformed param_name */ 1143| | 1144| 0| g_mutex_unlock (&pool->mutex); 1145| | 1146| | return NULL; 1147| 0|} g_param_spec_pool_list: 1309| 3|{ 1310| 3| GParamSpec **pspecs, **p; 1311| 3| GSList **slists, *node; 1312| 3| gpointer data[4]; 1313| 3| guint d, i; 1314| 3| int n_pspecs = 0; 1315| | 1316| 3| g_return_val_if_fail (pool != NULL, NULL); ------------------ | | 643| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 644| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 645| 3| { } \ | | 646| 3| else \ | | 647| 3| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1317| 3| g_return_val_if_fail (owner_type > 0, NULL); ------------------ | | 643| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 644| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 645| 3| { } \ | | 646| 3| else \ | | 647| 3| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1318| 3| g_return_val_if_fail (n_pspecs_p != NULL, NULL); ------------------ | | 643| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 644| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 645| 3| { } \ | | 646| 3| else \ | | 647| 3| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1319| | 1320| 3| g_mutex_lock (&pool->mutex); 1321| 3| d = g_type_depth (owner_type); 1322| 3| slists = g_new0 (GSList*, d); ------------------ | | 307| 3|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 3| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 3| gsize __n = (gsize) (n_structs); \ | | | | 237| 3| gsize __s = sizeof (struct_type); \ | | | | 238| 3| gpointer __p; \ | | | | 239| 3| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 3] | | | | ------------------ | | | | 240| 3| __p = g_##func (__n); \ | | | | 241| 3| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 3] | | | | ------------------ | | | | 242| 3| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 3| __p = g_##func (__n * __s); \ | | | | 244| 3| else \ | | | | 245| 3| __p = g_##func##_n (__n, __s); \ | | | | 246| 3| __p; \ | | | | 247| 3| })) | | ------------------ ------------------ 1323| 3| data[0] = slists; 1324| 3| data[1] = (gpointer) owner_type; 1325| 3| data[2] = pool->hash_table; 1326| 3| data[3] = &n_pspecs; 1327| | 1328| 3| g_hash_table_foreach (pool->hash_table, 1329| 3| G_TYPE_IS_INTERFACE (owner_type) ? ------------------ | | 293| 3|#define G_TYPE_IS_INTERFACE(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE) | | ------------------ | | | | 38| 3|#define G_TYPE_FUNDAMENTAL(type) (g_type_fundamental (type)) | | ------------------ | | #define G_TYPE_IS_INTERFACE(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 3|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 3|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 3|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (293:49): [True: 3, False: 0] | | ------------------ ------------------ 1330| 3| pool_depth_list_for_interface : 1331| 3| pool_depth_list, 1332| 3| &data); 1333| | 1334| 3| pspecs = g_new (GParamSpec*, n_pspecs + 1); ------------------ | | 290| 3|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 3| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 3| gsize __n = (gsize) (n_structs); \ | | | | 237| 3| gsize __s = sizeof (struct_type); \ | | | | 238| 3| gpointer __p; \ | | | | 239| 3| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 3] | | | | ------------------ | | | | 240| 3| __p = g_##func (__n); \ | | | | 241| 3| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 3] | | | | ------------------ | | | | 242| 3| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 3| __p = g_##func (__n * __s); \ | | | | 244| 3| else \ | | | | 245| 3| __p = g_##func##_n (__n, __s); \ | | | | 246| 3| __p; \ | | | | 247| 3| })) | | ------------------ ------------------ 1335| 3| p = pspecs; 1336| 9| for (i = 0; i < d; i++) ------------------ | Branch (1336:15): [True: 6, False: 3] ------------------ 1337| 6| { 1338| 6| slists[i] = g_slist_sort (slists[i], pspec_compare_id); 1339| 6| for (node = slists[i]; node; node = node->next) ------------------ | Branch (1339:30): [True: 0, False: 6] ------------------ 1340| 0| *p++ = node->data; 1341| 6| g_slist_free (slists[i]); 1342| 6| } 1343| 3| *p++ = NULL; 1344| 3| g_free (slists); 1345| 3| g_mutex_unlock (&pool->mutex); 1346| | 1347| 3| *n_pspecs_p = n_pspecs; 1348| | 1349| 3| return pspecs; 1350| 3|} g_param_type_register_static: 1414| 46|{ 1415| 46| GTypeInfo info = { 1416| 46| sizeof (GParamSpecClass), /* class_size */ 1417| 46| NULL, /* base_init */ 1418| 46| NULL, /* base_destroy */ 1419| 46| param_spec_generic_class_init, /* class_init */ 1420| 46| NULL, /* class_destroy */ 1421| 46| NULL, /* class_data */ 1422| 46| 0, /* instance_size */ 1423| 46| 16, /* n_preallocs */ 1424| 46| NULL, /* instance_init */ 1425| 46| NULL, /* value_table */ 1426| 46| }; 1427| 46| ParamSpecClassInfo *cinfo; 1428| | 1429| 46| g_return_val_if_fail (name != NULL, 0); ------------------ | | 643| 46| G_STMT_START { \ | | ------------------ | | | | 874| 46|#define G_STMT_START do | | ------------------ | | 644| 46| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 46|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 46| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 46|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 46| int _g_boolean_var_; \ | | | | | | 1018| 46| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 1019| 46| _g_boolean_var_ = 1; \ | | | | | | 1020| 46| else \ | | | | | | 1021| 46| _g_boolean_var_ = 0; \ | | | | | | 1022| 46| _g_boolean_var_; \ | | | | | | 1023| 46|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 46, False: 0] | | | | ------------------ | | ------------------ | | 645| 46| { } \ | | 646| 46| else \ | | 647| 46| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 46| } G_STMT_END | | ------------------ | | | | 882| 46|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 46] | | | | ------------------ | | ------------------ ------------------ 1430| 46| g_return_val_if_fail (pspec_info != NULL, 0); ------------------ | | 643| 46| G_STMT_START { \ | | ------------------ | | | | 874| 46|#define G_STMT_START do | | ------------------ | | 644| 46| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 46|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 46| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 46|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 46| int _g_boolean_var_; \ | | | | | | 1018| 46| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 1019| 46| _g_boolean_var_ = 1; \ | | | | | | 1020| 46| else \ | | | | | | 1021| 46| _g_boolean_var_ = 0; \ | | | | | | 1022| 46| _g_boolean_var_; \ | | | | | | 1023| 46|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 46, False: 0] | | | | ------------------ | | ------------------ | | 645| 46| { } \ | | 646| 46| else \ | | 647| 46| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 46| } G_STMT_END | | ------------------ | | | | 882| 46|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 46] | | | | ------------------ | | ------------------ ------------------ 1431| 46| g_return_val_if_fail (g_type_from_name (name) == 0, 0); ------------------ | | 643| 46| G_STMT_START { \ | | ------------------ | | | | 874| 46|#define G_STMT_START do | | ------------------ | | 644| 46| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 46|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 46| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 46|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 46| int _g_boolean_var_; \ | | | | | | 1018| 46| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 1019| 46| _g_boolean_var_ = 1; \ | | | | | | 1020| 46| else \ | | | | | | 1021| 46| _g_boolean_var_ = 0; \ | | | | | | 1022| 46| _g_boolean_var_; \ | | | | | | 1023| 46|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 46, False: 0] | | | | ------------------ | | ------------------ | | 645| 46| { } \ | | 646| 46| else \ | | 647| 46| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 46| } G_STMT_END | | ------------------ | | | | 882| 46|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 46] | | | | ------------------ | | ------------------ ------------------ 1432| 46| g_return_val_if_fail (pspec_info->instance_size >= sizeof (GParamSpec), 0); ------------------ | | 643| 46| G_STMT_START { \ | | ------------------ | | | | 874| 46|#define G_STMT_START do | | ------------------ | | 644| 46| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 46|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 46| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 46|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 46| int _g_boolean_var_; \ | | | | | | 1018| 46| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 1019| 46| _g_boolean_var_ = 1; \ | | | | | | 1020| 46| else \ | | | | | | 1021| 46| _g_boolean_var_ = 0; \ | | | | | | 1022| 46| _g_boolean_var_; \ | | | | | | 1023| 46|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 46, False: 0] | | | | ------------------ | | ------------------ | | 645| 46| { } \ | | 646| 46| else \ | | 647| 46| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 46| } G_STMT_END | | ------------------ | | | | 882| 46|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 46] | | | | ------------------ | | ------------------ ------------------ 1433| 46| g_return_val_if_fail (g_type_name (pspec_info->value_type) != NULL, 0); ------------------ | | 643| 46| G_STMT_START { \ | | ------------------ | | | | 874| 46|#define G_STMT_START do | | ------------------ | | 644| 46| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 46|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 46| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 46|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 46| int _g_boolean_var_; \ | | | | | | 1018| 46| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 1019| 46| _g_boolean_var_ = 1; \ | | | | | | 1020| 46| else \ | | | | | | 1021| 46| _g_boolean_var_ = 0; \ | | | | | | 1022| 46| _g_boolean_var_; \ | | | | | | 1023| 46|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 46, False: 0] | | | | ------------------ | | ------------------ | | 645| 46| { } \ | | 646| 46| else \ | | 647| 46| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 46| } G_STMT_END | | ------------------ | | | | 882| 46|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 46] | | | | ------------------ | | ------------------ ------------------ 1434| | /* default: g_return_val_if_fail (pspec_info->value_set_default != NULL, 0); */ 1435| | /* optional: g_return_val_if_fail (pspec_info->value_validate != NULL, 0); */ 1436| | /* default: g_return_val_if_fail (pspec_info->values_cmp != NULL, 0); */ 1437| | 1438| 46| info.instance_size = pspec_info->instance_size; 1439| 46| info.n_preallocs = pspec_info->n_preallocs; 1440| 46| info.instance_init = (GInstanceInitFunc) pspec_info->instance_init; 1441| 46| cinfo = g_new (ParamSpecClassInfo, 1); ------------------ | | 290| 46|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 46| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 46|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 46| gsize __n = (gsize) (n_structs); \ | | | | 237| 46| gsize __s = sizeof (struct_type); \ | | | | 238| 46| gpointer __p; \ | | | | 239| 46| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 46] | | | | ------------------ | | | | 240| 46| __p = g_##func (__n); \ | | | | 241| 46| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 46, False: 0] | | | | ------------------ | | | | 242| 46| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 46|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 46|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 46] | | | | | Branch (242:26): [True: 46, False: 0] | | | | ------------------ | | | | 243| 46| __p = g_##func (__n * __s); \ | | | | 244| 46| else \ | | | | 245| 46| __p = g_##func##_n (__n, __s); \ | | | | 246| 46| __p; \ | | | | 247| 46| })) | | ------------------ ------------------ 1442| 46| cinfo->value_type = pspec_info->value_type; 1443| 46| cinfo->finalize = pspec_info->finalize; 1444| 46| cinfo->value_set_default = pspec_info->value_set_default ? pspec_info->value_set_default : default_value_set_default; ------------------ | Branch (1444:30): [True: 46, False: 0] ------------------ 1445| 46| cinfo->value_validate = pspec_info->value_validate; 1446| 46| cinfo->values_cmp = pspec_info->values_cmp ? pspec_info->values_cmp : default_values_cmp; ------------------ | Branch (1446:23): [True: 46, False: 0] ------------------ 1447| 46| info.class_data = cinfo; 1448| | 1449| 46| return g_type_register_static (G_TYPE_PARAM, name, &info, 0); ------------------ | | 172| 46|#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) | | ------------------ | | | | 221| 46|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 46|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1450| 46|} g_param_spec_get_default_value: 1562| 3.85k|{ 1563| 3.85k| GParamSpecPrivate *priv = g_param_spec_get_private (pspec); 1564| | 1565| | /* We use the type field of the GValue as the key for the once because 1566| | * it will be zero before it is initialised and non-zero after. We 1567| | * have to take care that we don't write a non-zero value to the type 1568| | * field before we are completely done, however, because then another 1569| | * thread could come along and find the value partially-initialised. 1570| | * 1571| | * In order to accomplish this we store the default value in a 1572| | * stack-allocated GValue. We then set the type field in that value 1573| | * to zero and copy the contents into place. We then end by storing 1574| | * the type as the last step in order to ensure that we're completely 1575| | * done before a g_once_init_enter() could take the fast path in 1576| | * another thread. 1577| | */ 1578| 3.85k| if (g_once_init_enter (&priv->default_value.g_type)) ------------------ | | 257| 3.85k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | | Branch (257:3): [True: 1, False: 3.85k] | | ------------------ | | 258| 3.85k| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 259| 3.85k| (void) (0 ? (gpointer) *(location) : NULL); \ | | ------------------ | | | Branch (259:13): [Folded, False: 3.85k] | | ------------------ | | 260| 3.85k| (!g_atomic_pointer_get (location) && \ | | ------------------ | | | | 113| 7.70k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 7.70k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 3.85k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 7.70k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 3.85k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 7.70k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 7.70k| gapg_temp_newval; \ | | | | 119| 7.70k| })) | | ------------------ | | | Branch (260:6): [True: 1, False: 3.85k] | | ------------------ | | 261| 3.85k| g_once_init_enter (location)); \ | | ------------------ | | | Branch (261:6): [True: 1, False: 0] | | ------------------ | | 262| 3.85k| })) ------------------ 1579| 1| { 1580| 1| GValue default_value = G_VALUE_INIT; ------------------ | | 202| 1|#define G_VALUE_INIT { 0, { { 0 } } } ------------------ 1581| | 1582| 1| g_value_init (&default_value, pspec->value_type); 1583| 1| g_param_value_set_default (pspec, &default_value); 1584| | 1585| | /* store all but the type */ 1586| 1| memcpy (priv->default_value.data, default_value.data, sizeof (default_value.data)); 1587| | 1588| 1| g_once_init_leave (&priv->default_value.g_type, pspec->value_type); ------------------ | | 264| 1| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 265| 1| G_STATIC_ASSERT (sizeof *(location) == sizeof (gpointer)); \ | | ------------------ | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 266| 1| 0 ? (void) (*(location) = (result)) : (void) 0; \ | | ------------------ | | | Branch (266:5): [Folded, False: 1] | | ------------------ | | 267| 1| g_once_init_leave ((location), (gsize) (result)); \ | | 268| 1| })) ------------------ 1589| 1| } 1590| | 1591| 3.85k| return &priv->default_value; 1592| 3.85k|} g_param_spec_get_name_quark: 1606| 3.85k|{ 1607| 3.85k| GParamSpecPrivate *priv = g_param_spec_get_private (pspec); 1608| | 1609| | /* Return the quark that we've stashed away at creation time. 1610| | * This lets us avoid a lock and a hash table lookup when 1611| | * dispatching property change notification. 1612| | */ 1613| | 1614| 3.85k| return priv->name_quark; 1615| 3.85k|} gparam.c:g_param_spec_class_base_init: 148| 2|{ 149| 2|} gparam.c:g_param_spec_class_init: 159| 1|{ 160| 1| class->value_type = G_TYPE_NONE; ------------------ | | 62| 1|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 161| 1| class->finalize = g_param_spec_finalize; 162| 1| class->value_set_default = NULL; 163| 1| class->value_validate = NULL; 164| 1| class->values_cmp = NULL; 165| | 166| 1| g_type_class_adjust_private_offset (class, &g_param_private_offset); 167| 1|} gparam.c:g_param_spec_init: 172| 1|{ 173| 1| pspec->name = NULL; 174| 1| pspec->_nick = NULL; 175| 1| pspec->_blurb = NULL; 176| 1| pspec->flags = 0; 177| 1| pspec->value_type = class->value_type; 178| 1| pspec->owner_type = 0; 179| 1| pspec->qdata = NULL; 180| 1| g_datalist_set_flags (&pspec->qdata, PARAM_FLOATING_FLAG); ------------------ | | 56| 1|#define PARAM_FLOATING_FLAG 0x2 ------------------ 181| 1| pspec->ref_count = 1; 182| 1| pspec->param_id = 0; 183| 1|} gparam.c:is_canonical: 380| 4|{ 381| | return (strchr (key, '_') == NULL); 382| 4|} gparam.c:g_param_spec_get_private: 95| 7.70k|{ 96| 7.70k| return &G_STRUCT_MEMBER (GParamSpecPrivate, pspec, g_param_private_offset); ------------------ | | 862| 7.70k| (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset))) | | ------------------ | | | | 860| 7.70k| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ ------------------ 97| 7.70k|} gparam.c:param_spec_pool_hash: 906| 3|{ 907| 3| const GParamSpec *key = key_spec; 908| 3| const gchar *p; 909| 3| guint h = key->owner_type; 910| | 911| 21| for (p = key->name; *p; p++) ------------------ | Branch (911:23): [True: 18, False: 3] ------------------ 912| 18| h = (h << 5) - h + *p; 913| | 914| 3| return h; 915| 3|} gparam.c:param_spec_ht_lookup: 1026| 2|{ 1027| 2| GParamSpec key, *pspec; 1028| | 1029| 2| key.owner_type = owner_type; 1030| 2| key.name = (gchar*) param_name; 1031| 2| if (walk_ancestors) ------------------ | Branch (1031:7): [True: 1, False: 1] ------------------ 1032| 1| do 1033| 1| { 1034| 1| pspec = g_hash_table_lookup (hash_table, &key); 1035| 1| if (pspec) ------------------ | Branch (1035:6): [True: 0, False: 1] ------------------ 1036| 0| return pspec; 1037| 1| key.owner_type = g_type_parent (key.owner_type); 1038| 1| } 1039| 1| while (key.owner_type); ------------------ | Branch (1039:12): [True: 0, False: 1] ------------------ 1040| 1| else 1041| 1| pspec = g_hash_table_lookup (hash_table, &key); 1042| | 1043| 2| if (!pspec && !is_canonical (param_name)) ------------------ | Branch (1043:7): [True: 2, False: 0] | Branch (1043:17): [True: 0, False: 2] ------------------ 1044| 0| { 1045| 0| gchar *canonical; 1046| | 1047| 0| canonical = g_strdup (key.name); 1048| 0| canonicalize_key (canonical); 1049| | 1050| | /* try canonicalized form */ 1051| 0| key.name = canonical; 1052| 0| key.owner_type = owner_type; 1053| | 1054| 0| if (walk_ancestors) ------------------ | Branch (1054:11): [True: 0, False: 0] ------------------ 1055| 0| do 1056| 0| { 1057| 0| pspec = g_hash_table_lookup (hash_table, &key); 1058| 0| if (pspec) ------------------ | Branch (1058:17): [True: 0, False: 0] ------------------ 1059| 0| { 1060| 0| g_free (canonical); 1061| 0| return pspec; 1062| 0| } 1063| 0| key.owner_type = g_type_parent (key.owner_type); 1064| 0| } 1065| 0| while (key.owner_type); ------------------ | Branch (1065:16): [True: 0, False: 0] ------------------ 1066| 0| else 1067| 0| pspec = g_hash_table_lookup (hash_table, &key); 1068| | 1069| 0| g_free (canonical); 1070| 0| } 1071| | 1072| 2| return pspec; 1073| 2|} gparam.c:pool_depth_list_for_interface: 1276| 3|{ 1277| 3| GParamSpec *pspec = value; 1278| 3| gpointer *data = user_data; 1279| 3| GSList **slists = data[0]; 1280| 3| GType owner_type = (GType) data[1]; 1281| 3| GHashTable *ht = data[2]; 1282| 3| int *count = data[3]; 1283| | 1284| 3| if (pspec->owner_type == owner_type && ------------------ | Branch (1284:7): [True: 0, False: 3] ------------------ 1285| 0| should_list_pspec (pspec, owner_type, ht)) ------------------ | Branch (1285:7): [True: 0, False: 0] ------------------ 1286| 0| { 1287| 0| slists[0] = g_slist_prepend (slists[0], pspec); 1288| 0| *count = *count + 1; 1289| 0| } 1290| 3|} gparam.c:param_spec_generic_class_init: 1370| 1|{ 1371| 1| GParamSpecClass *class = g_class; 1372| 1| ParamSpecClassInfo *info = class_data; 1373| | 1374| 1| class->value_type = info->value_type; 1375| 1| if (info->finalize) ------------------ | Branch (1375:7): [True: 0, False: 1] ------------------ 1376| 0| class->finalize = info->finalize; /* optional */ 1377| 1| class->value_set_default = info->value_set_default; 1378| 1| if (info->value_validate) ------------------ | Branch (1378:7): [True: 1, False: 0] ------------------ 1379| 1| class->value_validate = info->value_validate; /* optional */ 1380| 1| class->values_cmp = info->values_cmp; 1381| 1| g_free (class_data); 1382| 1|} _g_param_spec_types_init: 1197| 2|{ 1198| 2| const guint n_types = 23; 1199| 2| GType type, *spec_types; 1200| 2|#ifndef G_DISABLE_ASSERT 1201| 2| GType *spec_types_bound; 1202| 2|#endif 1203| | 1204| 2| g_param_spec_types = g_new0 (GType, n_types); ------------------ | | 307| 2|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 2| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 2| gsize __n = (gsize) (n_structs); \ | | | | 237| 2| gsize __s = sizeof (struct_type); \ | | | | 238| 2| gpointer __p; \ | | | | 239| 2| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 2] | | | | ------------------ | | | | 240| 2| __p = g_##func (__n); \ | | | | 241| 2| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 2, False: 0] | | | | ------------------ | | | | 242| 2| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 2|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 2|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 2] | | | | | Branch (242:26): [True: 2, False: 0] | | | | ------------------ | | | | 243| 2| __p = g_##func (__n * __s); \ | | | | 244| 2| else \ | | | | 245| 2| __p = g_##func##_n (__n, __s); \ | | | | 246| 2| __p; \ | | | | 247| 2| })) | | ------------------ ------------------ 1205| 2| spec_types = g_param_spec_types; 1206| 2|#ifndef G_DISABLE_ASSERT 1207| 2| spec_types_bound = g_param_spec_types + n_types; 1208| 2|#endif 1209| | 1210| | /* G_TYPE_PARAM_CHAR 1211| | */ 1212| 2| { 1213| 2| const GParamSpecTypeInfo pspec_info = { 1214| 2| sizeof (GParamSpecChar), /* instance_size */ 1215| 2| 16, /* n_preallocs */ 1216| 2| param_char_init, /* instance_init */ 1217| 2| G_TYPE_CHAR, /* value_type */ ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1218| 2| NULL, /* finalize */ 1219| 2| param_char_set_default, /* value_set_default */ 1220| 2| param_char_validate, /* value_validate */ 1221| 2| param_int_values_cmp, /* values_cmp */ 1222| 2| }; 1223| 2| type = g_param_type_register_static (g_intern_static_string ("GParamChar"), &pspec_info); 1224| 2| *spec_types++ = type; 1225| 2| g_assert (type == G_TYPE_PARAM_CHAR); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1226| 2| } 1227| | 1228| | /* G_TYPE_PARAM_UCHAR 1229| | */ 1230| 2| { 1231| 2| const GParamSpecTypeInfo pspec_info = { 1232| 2| sizeof (GParamSpecUChar), /* instance_size */ 1233| 2| 16, /* n_preallocs */ 1234| 2| param_uchar_init, /* instance_init */ 1235| 2| G_TYPE_UCHAR, /* value_type */ ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1236| 2| NULL, /* finalize */ 1237| 2| param_uchar_set_default, /* value_set_default */ 1238| 2| param_uchar_validate, /* value_validate */ 1239| 2| param_uint_values_cmp, /* values_cmp */ 1240| 2| }; 1241| 2| type = g_param_type_register_static (g_intern_static_string ("GParamUChar"), &pspec_info); 1242| 2| *spec_types++ = type; 1243| 2| g_assert (type == G_TYPE_PARAM_UCHAR); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1244| 2| } 1245| | 1246| | /* G_TYPE_PARAM_BOOLEAN 1247| | */ 1248| 2| { 1249| 2| const GParamSpecTypeInfo pspec_info = { 1250| 2| sizeof (GParamSpecBoolean), /* instance_size */ 1251| 2| 16, /* n_preallocs */ 1252| 2| NULL, /* instance_init */ 1253| 2| G_TYPE_BOOLEAN, /* value_type */ ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1254| 2| NULL, /* finalize */ 1255| 2| param_boolean_set_default, /* value_set_default */ 1256| 2| param_boolean_validate, /* value_validate */ 1257| 2| param_int_values_cmp, /* values_cmp */ 1258| 2| }; 1259| 2| type = g_param_type_register_static (g_intern_static_string ("GParamBoolean"), &pspec_info); 1260| 2| *spec_types++ = type; 1261| 2| g_assert (type == G_TYPE_PARAM_BOOLEAN); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1262| 2| } 1263| | 1264| | /* G_TYPE_PARAM_INT 1265| | */ 1266| 2| { 1267| 2| const GParamSpecTypeInfo pspec_info = { 1268| 2| sizeof (GParamSpecInt), /* instance_size */ 1269| 2| 16, /* n_preallocs */ 1270| 2| param_int_init, /* instance_init */ 1271| 2| G_TYPE_INT, /* value_type */ ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1272| 2| NULL, /* finalize */ 1273| 2| param_int_set_default, /* value_set_default */ 1274| 2| param_int_validate, /* value_validate */ 1275| 2| param_int_values_cmp, /* values_cmp */ 1276| 2| }; 1277| 2| type = g_param_type_register_static (g_intern_static_string ("GParamInt"), &pspec_info); 1278| 2| *spec_types++ = type; 1279| 2| g_assert (type == G_TYPE_PARAM_INT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1280| 2| } 1281| | 1282| | /* G_TYPE_PARAM_UINT 1283| | */ 1284| 2| { 1285| 2| const GParamSpecTypeInfo pspec_info = { 1286| 2| sizeof (GParamSpecUInt), /* instance_size */ 1287| 2| 16, /* n_preallocs */ 1288| 2| param_uint_init, /* instance_init */ 1289| 2| G_TYPE_UINT, /* value_type */ ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1290| 2| NULL, /* finalize */ 1291| 2| param_uint_set_default, /* value_set_default */ 1292| 2| param_uint_validate, /* value_validate */ 1293| 2| param_uint_values_cmp, /* values_cmp */ 1294| 2| }; 1295| 2| type = g_param_type_register_static (g_intern_static_string ("GParamUInt"), &pspec_info); 1296| 2| *spec_types++ = type; 1297| 2| g_assert (type == G_TYPE_PARAM_UINT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1298| 2| } 1299| | 1300| | /* G_TYPE_PARAM_LONG 1301| | */ 1302| 2| { 1303| 2| const GParamSpecTypeInfo pspec_info = { 1304| 2| sizeof (GParamSpecLong), /* instance_size */ 1305| 2| 16, /* n_preallocs */ 1306| 2| param_long_init, /* instance_init */ 1307| 2| G_TYPE_LONG, /* value_type */ ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1308| 2| NULL, /* finalize */ 1309| 2| param_long_set_default, /* value_set_default */ 1310| 2| param_long_validate, /* value_validate */ 1311| 2| param_long_values_cmp, /* values_cmp */ 1312| 2| }; 1313| 2| type = g_param_type_register_static (g_intern_static_string ("GParamLong"), &pspec_info); 1314| 2| *spec_types++ = type; 1315| 2| g_assert (type == G_TYPE_PARAM_LONG); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1316| 2| } 1317| | 1318| | /* G_TYPE_PARAM_ULONG 1319| | */ 1320| 2| { 1321| 2| const GParamSpecTypeInfo pspec_info = { 1322| 2| sizeof (GParamSpecULong), /* instance_size */ 1323| 2| 16, /* n_preallocs */ 1324| 2| param_ulong_init, /* instance_init */ 1325| 2| G_TYPE_ULONG, /* value_type */ ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1326| 2| NULL, /* finalize */ 1327| 2| param_ulong_set_default, /* value_set_default */ 1328| 2| param_ulong_validate, /* value_validate */ 1329| 2| param_ulong_values_cmp, /* values_cmp */ 1330| 2| }; 1331| 2| type = g_param_type_register_static (g_intern_static_string ("GParamULong"), &pspec_info); 1332| 2| *spec_types++ = type; 1333| 2| g_assert (type == G_TYPE_PARAM_ULONG); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1334| 2| } 1335| | 1336| | /* G_TYPE_PARAM_INT64 1337| | */ 1338| 2| { 1339| 2| const GParamSpecTypeInfo pspec_info = { 1340| 2| sizeof (GParamSpecInt64), /* instance_size */ 1341| 2| 16, /* n_preallocs */ 1342| 2| param_int64_init, /* instance_init */ 1343| 2| G_TYPE_INT64, /* value_type */ ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1344| 2| NULL, /* finalize */ 1345| 2| param_int64_set_default, /* value_set_default */ 1346| 2| param_int64_validate, /* value_validate */ 1347| 2| param_int64_values_cmp, /* values_cmp */ 1348| 2| }; 1349| 2| type = g_param_type_register_static (g_intern_static_string ("GParamInt64"), &pspec_info); 1350| 2| *spec_types++ = type; 1351| 2| g_assert (type == G_TYPE_PARAM_INT64); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1352| 2| } 1353| | 1354| | /* G_TYPE_PARAM_UINT64 1355| | */ 1356| 2| { 1357| 2| const GParamSpecTypeInfo pspec_info = { 1358| 2| sizeof (GParamSpecUInt64), /* instance_size */ 1359| 2| 16, /* n_preallocs */ 1360| 2| param_uint64_init, /* instance_init */ 1361| 2| G_TYPE_UINT64, /* value_type */ ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1362| 2| NULL, /* finalize */ 1363| 2| param_uint64_set_default, /* value_set_default */ 1364| 2| param_uint64_validate, /* value_validate */ 1365| 2| param_uint64_values_cmp, /* values_cmp */ 1366| 2| }; 1367| 2| type = g_param_type_register_static (g_intern_static_string ("GParamUInt64"), &pspec_info); 1368| 2| *spec_types++ = type; 1369| 2| g_assert (type == G_TYPE_PARAM_UINT64); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1370| 2| } 1371| | 1372| | /* G_TYPE_PARAM_UNICHAR 1373| | */ 1374| 2| { 1375| 2| const GParamSpecTypeInfo pspec_info = { 1376| 2| sizeof (GParamSpecUnichar), /* instance_size */ 1377| 2| 16, /* n_preallocs */ 1378| 2| param_unichar_init, /* instance_init */ 1379| 2| G_TYPE_UINT, /* value_type */ ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1380| 2| NULL, /* finalize */ 1381| 2| param_unichar_set_default, /* value_set_default */ 1382| 2| param_unichar_validate, /* value_validate */ 1383| 2| param_unichar_values_cmp, /* values_cmp */ 1384| 2| }; 1385| 2| type = g_param_type_register_static (g_intern_static_string ("GParamUnichar"), &pspec_info); 1386| 2| *spec_types++ = type; 1387| 2| g_assert (type == G_TYPE_PARAM_UNICHAR); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1388| 2| } 1389| | 1390| | /* G_TYPE_PARAM_ENUM 1391| | */ 1392| 2| { 1393| 2| const GParamSpecTypeInfo pspec_info = { 1394| 2| sizeof (GParamSpecEnum), /* instance_size */ 1395| 2| 16, /* n_preallocs */ 1396| 2| param_enum_init, /* instance_init */ 1397| 2| G_TYPE_ENUM, /* value_type */ ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1398| 2| param_enum_finalize, /* finalize */ 1399| 2| param_enum_set_default, /* value_set_default */ 1400| 2| param_enum_validate, /* value_validate */ 1401| 2| param_long_values_cmp, /* values_cmp */ 1402| 2| }; 1403| 2| type = g_param_type_register_static (g_intern_static_string ("GParamEnum"), &pspec_info); 1404| 2| *spec_types++ = type; 1405| 2| g_assert (type == G_TYPE_PARAM_ENUM); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1406| 2| } 1407| | 1408| | /* G_TYPE_PARAM_FLAGS 1409| | */ 1410| 2| { 1411| 2| const GParamSpecTypeInfo pspec_info = { 1412| 2| sizeof (GParamSpecFlags), /* instance_size */ 1413| 2| 16, /* n_preallocs */ 1414| 2| param_flags_init, /* instance_init */ 1415| 2| G_TYPE_FLAGS, /* value_type */ ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1416| 2| param_flags_finalize, /* finalize */ 1417| 2| param_flags_set_default, /* value_set_default */ 1418| 2| param_flags_validate, /* value_validate */ 1419| 2| param_ulong_values_cmp, /* values_cmp */ 1420| 2| }; 1421| 2| type = g_param_type_register_static (g_intern_static_string ("GParamFlags"), &pspec_info); 1422| 2| *spec_types++ = type; 1423| 2| g_assert (type == G_TYPE_PARAM_FLAGS); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1424| 2| } 1425| | 1426| | /* G_TYPE_PARAM_FLOAT 1427| | */ 1428| 2| { 1429| 2| const GParamSpecTypeInfo pspec_info = { 1430| 2| sizeof (GParamSpecFloat), /* instance_size */ 1431| 2| 16, /* n_preallocs */ 1432| 2| param_float_init, /* instance_init */ 1433| 2| G_TYPE_FLOAT, /* value_type */ ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1434| 2| NULL, /* finalize */ 1435| 2| param_float_set_default, /* value_set_default */ 1436| 2| param_float_validate, /* value_validate */ 1437| 2| param_float_values_cmp, /* values_cmp */ 1438| 2| }; 1439| 2| type = g_param_type_register_static (g_intern_static_string ("GParamFloat"), &pspec_info); 1440| 2| *spec_types++ = type; 1441| 2| g_assert (type == G_TYPE_PARAM_FLOAT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1442| 2| } 1443| | 1444| | /* G_TYPE_PARAM_DOUBLE 1445| | */ 1446| 2| { 1447| 2| const GParamSpecTypeInfo pspec_info = { 1448| 2| sizeof (GParamSpecDouble), /* instance_size */ 1449| 2| 16, /* n_preallocs */ 1450| 2| param_double_init, /* instance_init */ 1451| 2| G_TYPE_DOUBLE, /* value_type */ ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1452| 2| NULL, /* finalize */ 1453| 2| param_double_set_default, /* value_set_default */ 1454| 2| param_double_validate, /* value_validate */ 1455| 2| param_double_values_cmp, /* values_cmp */ 1456| 2| }; 1457| 2| type = g_param_type_register_static (g_intern_static_string ("GParamDouble"), &pspec_info); 1458| 2| *spec_types++ = type; 1459| 2| g_assert (type == G_TYPE_PARAM_DOUBLE); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1460| 2| } 1461| | 1462| | /* G_TYPE_PARAM_STRING 1463| | */ 1464| 2| { 1465| 2| const GParamSpecTypeInfo pspec_info = { 1466| 2| sizeof (GParamSpecString), /* instance_size */ 1467| 2| 16, /* n_preallocs */ 1468| 2| param_string_init, /* instance_init */ 1469| 2| G_TYPE_STRING, /* value_type */ ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1470| 2| param_string_finalize, /* finalize */ 1471| 2| param_string_set_default, /* value_set_default */ 1472| 2| param_string_validate, /* value_validate */ 1473| 2| param_string_values_cmp, /* values_cmp */ 1474| 2| }; 1475| 2| type = g_param_type_register_static (g_intern_static_string ("GParamString"), &pspec_info); 1476| 2| *spec_types++ = type; 1477| 2| g_assert (type == G_TYPE_PARAM_STRING); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1478| 2| } 1479| | 1480| | /* G_TYPE_PARAM_PARAM 1481| | */ 1482| 2| { 1483| 2| const GParamSpecTypeInfo pspec_info = { 1484| 2| sizeof (GParamSpecParam), /* instance_size */ 1485| 2| 16, /* n_preallocs */ 1486| 2| param_param_init, /* instance_init */ 1487| 2| G_TYPE_PARAM, /* value_type */ ------------------ | | 172| 2|#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1488| 2| NULL, /* finalize */ 1489| 2| param_param_set_default, /* value_set_default */ 1490| 2| param_param_validate, /* value_validate */ 1491| 2| param_pointer_values_cmp, /* values_cmp */ 1492| 2| }; 1493| 2| type = g_param_type_register_static (g_intern_static_string ("GParamParam"), &pspec_info); 1494| 2| *spec_types++ = type; 1495| 2| g_assert (type == G_TYPE_PARAM_PARAM); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1496| 2| } 1497| | 1498| | /* G_TYPE_PARAM_BOXED 1499| | */ 1500| 2| { 1501| 2| const GParamSpecTypeInfo pspec_info = { 1502| 2| sizeof (GParamSpecBoxed), /* instance_size */ 1503| 2| 4, /* n_preallocs */ 1504| 2| param_boxed_init, /* instance_init */ 1505| 2| G_TYPE_BOXED, /* value_type */ ------------------ | | 166| 2|#define G_TYPE_BOXED G_TYPE_MAKE_FUNDAMENTAL (18) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1506| 2| NULL, /* finalize */ 1507| 2| param_boxed_set_default, /* value_set_default */ 1508| 2| param_boxed_validate, /* value_validate */ 1509| 2| param_boxed_values_cmp, /* values_cmp */ 1510| 2| }; 1511| 2| type = g_param_type_register_static (g_intern_static_string ("GParamBoxed"), &pspec_info); 1512| 2| *spec_types++ = type; 1513| 2| g_assert (type == G_TYPE_PARAM_BOXED); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1514| 2| } 1515| | 1516| | /* G_TYPE_PARAM_POINTER 1517| | */ 1518| 2| { 1519| 2| const GParamSpecTypeInfo pspec_info = { 1520| 2| sizeof (GParamSpecPointer), /* instance_size */ 1521| 2| 0, /* n_preallocs */ 1522| 2| param_pointer_init, /* instance_init */ 1523| 2| G_TYPE_POINTER, /* value_type */ ------------------ | | 160| 2|#define G_TYPE_POINTER G_TYPE_MAKE_FUNDAMENTAL (17) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1524| 2| NULL, /* finalize */ 1525| 2| param_pointer_set_default, /* value_set_default */ 1526| 2| param_pointer_validate, /* value_validate */ 1527| 2| param_pointer_values_cmp, /* values_cmp */ 1528| 2| }; 1529| 2| type = g_param_type_register_static (g_intern_static_string ("GParamPointer"), &pspec_info); 1530| 2| *spec_types++ = type; 1531| 2| g_assert (type == G_TYPE_PARAM_POINTER); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1532| 2| } 1533| | 1534| | /* G_TYPE_PARAM_VALUE_ARRAY 1535| | */ 1536| 2| { 1537| 2| /* const */ GParamSpecTypeInfo pspec_info = { 1538| 2| sizeof (GParamSpecValueArray), /* instance_size */ 1539| 2| 0, /* n_preallocs */ 1540| 2| param_value_array_init, /* instance_init */ 1541| 2| 0xdeadbeef, /* value_type, assigned further down */ 1542| 2| param_value_array_finalize, /* finalize */ 1543| 2| param_value_array_set_default, /* value_set_default */ 1544| 2| param_value_array_validate, /* value_validate */ 1545| 2| param_value_array_values_cmp, /* values_cmp */ 1546| 2| }; 1547| 2| pspec_info.value_type = G_TYPE_VALUE_ARRAY; ------------------ | | 38| 2|#define G_TYPE_VALUE_ARRAY (g_value_array_get_type ()) GLIB_DEPRECATED_MACRO_IN_2_32_FOR(G_TYPE_ARRAY) ------------------ 1548| 2| type = g_param_type_register_static (g_intern_static_string ("GParamValueArray"), &pspec_info); 1549| 2| *spec_types++ = type; 1550| 2| g_assert (type == G_TYPE_PARAM_VALUE_ARRAY); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1551| 2| } 1552| | 1553| | /* G_TYPE_PARAM_OBJECT 1554| | */ 1555| 2| { 1556| 2| const GParamSpecTypeInfo pspec_info = { 1557| 2| sizeof (GParamSpecObject), /* instance_size */ 1558| 2| 16, /* n_preallocs */ 1559| 2| param_object_init, /* instance_init */ 1560| 2| G_TYPE_OBJECT, /* value_type */ ------------------ | | 178| 2|#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1561| 2| NULL, /* finalize */ 1562| 2| param_object_set_default, /* value_set_default */ 1563| 2| param_object_validate, /* value_validate */ 1564| 2| param_object_values_cmp, /* values_cmp */ 1565| 2| }; 1566| 2| type = g_param_type_register_static (g_intern_static_string ("GParamObject"), &pspec_info); 1567| 2| *spec_types++ = type; 1568| 2| g_assert (type == G_TYPE_PARAM_OBJECT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1569| 2| } 1570| | 1571| | /* G_TYPE_PARAM_OVERRIDE 1572| | */ 1573| 2| { 1574| 2| const GParamSpecTypeInfo pspec_info = { 1575| 2| sizeof (GParamSpecOverride), /* instance_size */ 1576| 2| 16, /* n_preallocs */ 1577| 2| param_override_init, /* instance_init */ 1578| 2| G_TYPE_NONE, /* value_type */ ------------------ | | 62| 2|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1579| 2| param_override_finalize, /* finalize */ 1580| 2| param_override_set_default, /* value_set_default */ 1581| 2| param_override_validate, /* value_validate */ 1582| 2| param_override_values_cmp, /* values_cmp */ 1583| 2| }; 1584| 2| type = g_param_type_register_static (g_intern_static_string ("GParamOverride"), &pspec_info); 1585| 2| *spec_types++ = type; 1586| 2| g_assert (type == G_TYPE_PARAM_OVERRIDE); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1587| 2| } 1588| | 1589| | /* G_TYPE_PARAM_GTYPE 1590| | */ 1591| 2| { 1592| 2| GParamSpecTypeInfo pspec_info = { 1593| 2| sizeof (GParamSpecGType), /* instance_size */ 1594| 2| 0, /* n_preallocs */ 1595| 2| param_gtype_init, /* instance_init */ 1596| 2| 0xdeadbeef, /* value_type, assigned further down */ 1597| 2| NULL, /* finalize */ 1598| 2| param_gtype_set_default, /* value_set_default */ 1599| 2| param_gtype_validate, /* value_validate */ 1600| 2| param_gtype_values_cmp, /* values_cmp */ 1601| 2| }; 1602| 2| pspec_info.value_type = G_TYPE_GTYPE; ------------------ | | 166| 2|#define G_TYPE_GTYPE (g_gtype_get_type()) ------------------ 1603| 2| type = g_param_type_register_static (g_intern_static_string ("GParamGType"), &pspec_info); 1604| 2| *spec_types++ = type; 1605| 2| g_assert (type == G_TYPE_PARAM_GTYPE); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1606| 2| } 1607| | 1608| | /* G_TYPE_PARAM_VARIANT 1609| | */ 1610| 2| { 1611| 2| const GParamSpecTypeInfo pspec_info = { 1612| 2| sizeof (GParamSpecVariant), /* instance_size */ 1613| 2| 0, /* n_preallocs */ 1614| 2| param_variant_init, /* instance_init */ 1615| 2| G_TYPE_VARIANT, /* value_type */ ------------------ | | 196| 2|#define G_TYPE_VARIANT G_TYPE_MAKE_FUNDAMENTAL (21) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1616| 2| param_variant_finalize, /* finalize */ 1617| 2| param_variant_set_default, /* value_set_default */ 1618| 2| param_variant_validate, /* value_validate */ 1619| 2| param_variant_values_cmp, /* values_cmp */ 1620| 2| }; 1621| 2| type = g_param_type_register_static (g_intern_static_string ("GParamVariant"), &pspec_info); 1622| 2| *spec_types++ = type; 1623| 2| g_assert (type == G_TYPE_PARAM_VARIANT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1624| 2| } 1625| | 1626| 2| g_assert (spec_types == spec_types_bound); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1627| 2|} g_param_spec_object: 2508| 1|{ 2509| 1| GParamSpecObject *ospec; 2510| | 2511| 1| g_return_val_if_fail (g_type_is_a (object_type, G_TYPE_OBJECT), NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 2512| | 2513| 1| ospec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, ------------------ | | 482| 1|#define G_TYPE_PARAM_OBJECT (g_param_spec_types[19]) ------------------ 2514| 1| name, 2515| 1| nick, 2516| 1| blurb, 2517| 1| flags); 2518| 1| if (ospec == NULL) ------------------ | Branch (2518:7): [True: 0, False: 1] ------------------ 2519| 0| return NULL; 2520| | 2521| 1| G_PARAM_SPEC (ospec)->value_type = object_type; ------------------ | | 45| 1|#define G_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM, GParamSpec)) | | ------------------ | | | | 484| 1|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 1| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 2522| | 2523| 1| return G_PARAM_SPEC (ospec); ------------------ | | 45| 1|#define G_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM, GParamSpec)) | | ------------------ | | | | 484| 1|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 1| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 2524| 1|} gparamspecs.c:param_object_init: 973| 1|{ 974| | /* GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec); */ 975| 1|} gparamspecs.c:param_object_set_default: 980| 1|{ 981| | value->data[0].v_pointer = NULL; 982| 1|} gparamspecs.c:param_object_validate: 987| 3.85k|{ 988| 3.85k| GParamSpecObject *ospec = G_PARAM_SPEC_OBJECT (pspec); ------------------ | | 498| 3.85k|#define G_PARAM_SPEC_OBJECT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OBJECT, GParamSpecObject)) | | ------------------ | | | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | ------------------ | | | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | ------------------ | | ------------------ ------------------ 989| 3.85k| GObject *object = value->data[0].v_pointer; 990| 3.85k| guint changed = 0; 991| | 992| 3.85k| if (object && !g_value_type_compatible (G_OBJECT_TYPE (object), G_PARAM_SPEC_VALUE_TYPE (ospec))) ------------------ | | 100| 0|#define G_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object)) | | ------------------ | | | | 602| 0|#define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class)) | | | | ------------------ | | | | | | 613| 0|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) | | | | ------------------ | | ------------------ ------------------ if (object && !g_value_type_compatible (G_OBJECT_TYPE (object), G_PARAM_SPEC_VALUE_TYPE (ospec))) ------------------ | | 103| 0|#define G_PARAM_SPEC_VALUE_TYPE(pspec) (G_PARAM_SPEC (pspec)->value_type) | | ------------------ | | | | 45| 0|#define G_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM, GParamSpec)) | | | | ------------------ | | | | | | 484| 0|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | | | | | ------------------ | | | | | | | | 2300| 0| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (992:7): [True: 0, False: 3.85k] | Branch (992:17): [True: 0, False: 0] ------------------ 993| 0| { 994| 0| g_object_unref (object); 995| 0| value->data[0].v_pointer = NULL; 996| 0| changed++; 997| 0| } 998| | 999| 3.85k| return changed; 1000| 3.85k|} g_signal_is_valid_name: 386| 1|{ 387| | /* FIXME: We allow this, against our own documentation (the leading `-` is 388| | * invalid), because GTK has historically used this. */ 389| 1| if (g_str_equal (name, "-gtk-private-changed")) ------------------ | Branch (389:7): [True: 0, False: 1] ------------------ 390| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 391| | 392| 1| return g_param_spec_is_valid_name (name); 393| 1|} _g_signal_init: 926| 2|{ 927| 2| SIGNAL_LOCK (); ------------------ | | 328| 2|#define SIGNAL_LOCK() G_LOCK (g_signal_mutex) | | ------------------ | | | | 135| 2|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 2|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 928| 2| if (!g_n_signal_nodes) ------------------ | Branch (928:7): [True: 2, False: 0] ------------------ 929| 2| { 930| | /* setup handler list binary searchable array hash table (in german, that'd be one word ;) */ 931| 2| g_handler_list_bsa_ht = g_hash_table_new (g_direct_hash, NULL); 932| 2| g_signal_key_bsa = g_bsearch_array_create (&g_signal_key_bconfig); 933| | 934| | /* invalid (0) signal_id */ 935| 2| g_n_signal_nodes = 1; 936| 2| g_signal_nodes = g_renew (SignalNode*, g_signal_nodes, g_n_signal_nodes); ------------------ | | 321| 2|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 2| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 2| gsize __n = (gsize) (n_structs); \ | | | | 251| 2| gsize __s = sizeof (struct_type); \ | | | | 252| 2| gpointer __p = (gpointer) (mem); \ | | | | 253| 2| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 2] | | | | ------------------ | | | | 254| 2| __p = g_##func (__p, __n); \ | | | | 255| 2| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 2, False: 0] | | | | ------------------ | | | | 256| 2| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 2|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 2|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 2] | | | | | Branch (256:26): [True: 2, False: 0] | | | | ------------------ | | | | 257| 2| __p = g_##func (__p, __n * __s); \ | | | | 258| 2| else \ | | | | 259| 2| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 2| __p; \ | | | | 261| 2| })) | | ------------------ ------------------ 937| 2| g_signal_nodes[0] = NULL; 938| 2| g_handlers = g_hash_table_new (handler_hash, handler_equal); 939| 2| } 940| 2| SIGNAL_UNLOCK (); ------------------ | | 329| 2|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 2|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 2|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 941| 2|} g_signal_new: 1504| 1|{ 1505| 1| va_list args; 1506| 1| guint signal_id; 1507| | 1508| 1| g_return_val_if_fail (signal_name != NULL, 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1509| | 1510| 1| va_start (args, n_params); 1511| | 1512| 1| signal_id = g_signal_new_valist (signal_name, itype, signal_flags, 1513| 1| class_offset ? g_signal_type_cclosure_new (itype, class_offset) : NULL, ------------------ | Branch (1513:36): [True: 1, False: 0] ------------------ 1514| 1| accumulator, accu_data, c_marshaller, 1515| 1| return_type, n_params, args); 1516| | 1517| 1| va_end (args); 1518| | 1519| 1| return signal_id; 1520| 1|} g_signal_newv: 1701| 1|{ 1702| 1| const gchar *name; 1703| 1| gchar *signal_name_copy = NULL; 1704| 1| guint signal_id, i; 1705| 1| SignalNode *node; 1706| 1| GSignalCMarshaller builtin_c_marshaller; 1707| 1| GSignalCVaMarshaller builtin_va_marshaller; 1708| 1| GSignalCVaMarshaller va_marshaller; 1709| | 1710| 1| g_return_val_if_fail (signal_name != NULL, 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1711| 1| g_return_val_if_fail (g_signal_is_valid_name (signal_name), 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1712| 1| g_return_val_if_fail (G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype), 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1713| 1| if (n_params) ------------------ | Branch (1713:7): [True: 1, False: 0] ------------------ 1714| 1| g_return_val_if_fail (param_types != NULL, 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1715| 1| g_return_val_if_fail ((return_type & G_SIGNAL_TYPE_STATIC_SCOPE) == 0, 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1716| 1| if (return_type == (G_TYPE_NONE & ~G_SIGNAL_TYPE_STATIC_SCOPE)) ------------------ | | 62| 1|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ if (return_type == (G_TYPE_NONE & ~G_SIGNAL_TYPE_STATIC_SCOPE)) ------------------ | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ | Branch (1716:7): [True: 1, False: 0] ------------------ 1717| 1| g_return_val_if_fail (accumulator == NULL, 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1718| 1| if (!accumulator) ------------------ | Branch (1718:7): [True: 1, False: 0] ------------------ 1719| 1| g_return_val_if_fail (accu_data == NULL, 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1720| 1| g_return_val_if_fail ((signal_flags & G_SIGNAL_ACCUMULATOR_FIRST_RUN) == 0, 0); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1721| | 1722| 1| if (!is_canonical (signal_name)) ------------------ | Branch (1722:7): [True: 0, False: 1] ------------------ 1723| 0| { 1724| 0| signal_name_copy = g_strdup (signal_name); 1725| 0| canonicalize_key (signal_name_copy); 1726| 0| name = signal_name_copy; 1727| 0| } 1728| 1| else 1729| 1| { 1730| 1| name = signal_name; 1731| 1| } 1732| | 1733| 1| SIGNAL_LOCK (); ------------------ | | 328| 1|#define SIGNAL_LOCK() G_LOCK (g_signal_mutex) | | ------------------ | | | | 135| 1|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 1|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 1734| | 1735| 1| signal_id = signal_id_lookup (name, itype); 1736| 1| node = LOOKUP_SIGNAL_NODE (signal_id); 1737| 1| if (node && !node->destroyed) ------------------ | Branch (1737:7): [True: 0, False: 1] | Branch (1737:15): [True: 0, False: 0] ------------------ 1738| 0| { 1739| 0| g_warning (G_STRLOC ": signal \"%s\" already exists in the '%s' %s", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) | | ------------------ | | | Branch (347:32): [True: 0, False: 0] | | ------------------ ------------------ 1740| 0| name, 1741| 0| type_debug_name (node->itype), 1742| 0| G_TYPE_IS_INTERFACE (node->itype) ? "interface" : "class ancestry"); 1743| 0| g_free (signal_name_copy); 1744| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 1745| 0| return 0; 1746| 0| } 1747| 1| if (node && node->itype != itype) ------------------ | Branch (1747:7): [True: 0, False: 1] | Branch (1747:15): [True: 0, False: 0] ------------------ 1748| 0| { 1749| 0| g_warning (G_STRLOC ": signal \"%s\" for type '%s' was previously created for type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1750| 0| name, 1751| 0| type_debug_name (itype), 1752| 0| type_debug_name (node->itype)); 1753| 0| g_free (signal_name_copy); 1754| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 1755| 0| return 0; 1756| 0| } 1757| 2| for (i = 0; i < n_params; i++) ------------------ | Branch (1757:15): [True: 1, False: 1] ------------------ 1758| 1| if (!G_TYPE_IS_VALUE (param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE)) ------------------ | | 41| 1|#define G_TYPE_IS_VALUE(type) (g_type_check_is_value_type (type)) ------------------ | Branch (1758:9): [True: 0, False: 1] ------------------ 1759| 0| { 1760| 0| g_warning (G_STRLOC ": parameter %d of type '%s' for signal \"%s::%s\" is not a value type", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1761| 0| i + 1, type_debug_name (param_types[i]), type_debug_name (itype), name); 1762| 0| g_free (signal_name_copy); 1763| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 1764| 0| return 0; 1765| 0| } 1766| 1| if (return_type != G_TYPE_NONE && !G_TYPE_IS_VALUE (return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE)) ------------------ | | 62| 1|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ if (return_type != G_TYPE_NONE && !G_TYPE_IS_VALUE (return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE)) ------------------ | | 41| 0|#define G_TYPE_IS_VALUE(type) (g_type_check_is_value_type (type)) ------------------ | Branch (1766:7): [True: 0, False: 1] | Branch (1766:37): [True: 0, False: 0] ------------------ 1767| 0| { 1768| 0| g_warning (G_STRLOC ": return value of type '%s' for signal \"%s::%s\" is not a value type", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1769| 0| type_debug_name (return_type), type_debug_name (itype), name); 1770| 0| g_free (signal_name_copy); 1771| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 1772| 0| return 0; 1773| 0| } 1774| | 1775| | /* setup permanent portion of signal node */ 1776| 1| if (!node) ------------------ | Branch (1776:7): [True: 1, False: 0] ------------------ 1777| 1| { 1778| 1| SignalKey key; 1779| | 1780| 1| signal_id = g_n_signal_nodes++; 1781| 1| node = g_new (SignalNode, 1); ------------------ | | 290| 1|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 1| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 1| gsize __n = (gsize) (n_structs); \ | | | | 237| 1| gsize __s = sizeof (struct_type); \ | | | | 238| 1| gpointer __p; \ | | | | 239| 1| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 1] | | | | ------------------ | | | | 240| 1| __p = g_##func (__n); \ | | | | 241| 1| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 1, False: 0] | | | | ------------------ | | | | 242| 1| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 1|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 1|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 1] | | | | | Branch (242:26): [True: 1, False: 0] | | | | ------------------ | | | | 243| 1| __p = g_##func (__n * __s); \ | | | | 244| 1| else \ | | | | 245| 1| __p = g_##func##_n (__n, __s); \ | | | | 246| 1| __p; \ | | | | 247| 1| })) | | ------------------ ------------------ 1782| 1| node->signal_id = signal_id; 1783| 1| g_signal_nodes = g_renew (SignalNode*, g_signal_nodes, g_n_signal_nodes); ------------------ | | 321| 1|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 1| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 1| gsize __n = (gsize) (n_structs); \ | | | | 251| 1| gsize __s = sizeof (struct_type); \ | | | | 252| 1| gpointer __p = (gpointer) (mem); \ | | | | 253| 1| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 1] | | | | ------------------ | | | | 254| 1| __p = g_##func (__p, __n); \ | | | | 255| 1| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 0, False: 1] | | | | ------------------ | | | | 256| 1| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 0] | | | | | Branch (256:26): [True: 0, False: 0] | | | | ------------------ | | | | 257| 1| __p = g_##func (__p, __n * __s); \ | | | | 258| 1| else \ | | | | 259| 1| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 1| __p; \ | | | | 261| 1| })) | | ------------------ ------------------ 1784| 1| g_signal_nodes[signal_id] = node; 1785| 1| node->itype = itype; 1786| 1| key.itype = itype; 1787| 1| key.signal_id = signal_id; 1788| 1| node->name = g_intern_string (name); 1789| 1| key.quark = g_quark_from_string (name); 1790| 1| g_signal_key_bsa = g_bsearch_array_insert (g_signal_key_bsa, &g_signal_key_bconfig, &key); 1791| | 1792| 1| TRACE(GOBJECT_SIGNAL_NEW(signal_id, name, itype)); 1793| 1| } 1794| 1| node->destroyed = FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 1795| | 1796| | /* setup reinitializable portion */ 1797| 1| node->single_va_closure_is_valid = FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 1798| 1| node->flags = signal_flags & G_SIGNAL_FLAGS_MASK; ------------------ | | 149| 1|#define G_SIGNAL_FLAGS_MASK 0x1ff ------------------ 1799| 1| node->n_params = n_params; 1800| 1| node->param_types = g_memdup2 (param_types, sizeof (GType) * n_params); 1801| 1| node->return_type = return_type; 1802| 1| node->class_closure_bsa = NULL; 1803| 1| if (accumulator) ------------------ | Branch (1803:7): [True: 0, False: 1] ------------------ 1804| 0| { 1805| 0| node->accumulator = g_new (SignalAccumulator, 1); ------------------ | | 290| 0|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 0| gsize __n = (gsize) (n_structs); \ | | | | 237| 0| gsize __s = sizeof (struct_type); \ | | | | 238| 0| gpointer __p; \ | | | | 239| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 0] | | | | ------------------ | | | | 240| 0| __p = g_##func (__n); \ | | | | 241| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 0| __p; \ | | | | 247| 0| })) | | ------------------ ------------------ 1806| 0| node->accumulator->func = accumulator; 1807| 0| node->accumulator->data = accu_data; 1808| 0| } 1809| 1| else 1810| 1| node->accumulator = NULL; 1811| | 1812| 1| builtin_c_marshaller = NULL; 1813| 1| builtin_va_marshaller = NULL; 1814| | 1815| | /* Pick up built-in va marshallers for standard types, and 1816| | instead of generic marshaller if no marshaller specified */ 1817| 1| if (n_params == 0 && return_type == G_TYPE_NONE) ------------------ | | 62| 0|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (1817:7): [True: 0, False: 1] | Branch (1817:24): [True: 0, False: 0] ------------------ 1818| 0| { 1819| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__VOID; 1820| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__VOIDv; 1821| 0| } 1822| 1| else if (n_params == 1 && return_type == G_TYPE_NONE) ------------------ | | 62| 1|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (1822:12): [True: 1, False: 0] | Branch (1822:29): [True: 1, False: 0] ------------------ 1823| 1| { 1824| 1|#define ADD_CHECK(__type__) \ 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ 1826| 1| { \ 1827| 1| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ 1828| 1| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ 1829| 1| } 1830| | 1831| 1| if (0) {} ------------------ | Branch (1831:11): [Folded, False: 1] ------------------ 1832| 1| ADD_CHECK (BOOLEAN) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 88| 1|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1833| 1| ADD_CHECK (CHAR) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 76| 1|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1834| 1| ADD_CHECK (UCHAR) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 82| 1|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1835| 1| ADD_CHECK (INT) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 94| 1|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1836| 1| ADD_CHECK (UINT) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 100| 1|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1837| 1| ADD_CHECK (LONG) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 106| 1|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1838| 1| ADD_CHECK (ULONG) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 112| 1|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1839| 1| ADD_CHECK (ENUM) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 130| 1|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1840| 1| ADD_CHECK (FLAGS) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 136| 1|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1841| 1| ADD_CHECK (FLOAT) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 142| 1|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1842| 1| ADD_CHECK (DOUBLE) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 148| 1|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1843| 1| ADD_CHECK (STRING) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 154| 1|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 1] | | ------------------ | | 1826| 1| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1844| 1| ADD_CHECK (PARAM) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 1|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 1|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 172| 1|#define G_TYPE_PARAM G_TYPE_MAKE_FUNDAMENTAL (19) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 1, False: 0] | | ------------------ | | 1826| 1| { \ | | 1827| 1| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 1| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 1| } ------------------ 1845| 1| ADD_CHECK (BOXED) ------------------ | | 1825| 1| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 166| 0|#define G_TYPE_BOXED G_TYPE_MAKE_FUNDAMENTAL (18) | | | | ------------------ | | | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 0] | | ------------------ | | 1826| 0| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1846| 0| ADD_CHECK (POINTER) ------------------ | | 1825| 0| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 160| 0|#define G_TYPE_POINTER G_TYPE_MAKE_FUNDAMENTAL (17) | | | | ------------------ | | | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 0] | | ------------------ | | 1826| 0| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1847| 0| ADD_CHECK (OBJECT) ------------------ | | 1825| 0| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 178| 0|#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20) | | | | ------------------ | | | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 0] | | ------------------ | | 1826| 0| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1848| 0| ADD_CHECK (VARIANT) ------------------ | | 1825| 0| else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | | | ------------------ | | | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | | | ------------------ | | ------------------ | | else if (g_type_is_a (param_types[0] & ~G_SIGNAL_TYPE_STATIC_SCOPE, G_TYPE_ ##__type__)) \ | | ------------------ | | | | 196| 0|#define G_TYPE_VARIANT G_TYPE_MAKE_FUNDAMENTAL (21) | | | | ------------------ | | | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1825:16): [True: 0, False: 0] | | ------------------ | | 1826| 0| { \ | | 1827| 0| builtin_c_marshaller = g_cclosure_marshal_VOID__ ## __type__; \ | | 1828| 0| builtin_va_marshaller = g_cclosure_marshal_VOID__ ## __type__ ##v; \ | | 1829| 0| } ------------------ 1849| 1| } 1850| | 1851| 1| if (c_marshaller == NULL) ------------------ | Branch (1851:7): [True: 1, False: 0] ------------------ 1852| 1| { 1853| 1| if (builtin_c_marshaller) ------------------ | Branch (1853:11): [True: 1, False: 0] ------------------ 1854| 1| { 1855| 1| c_marshaller = builtin_c_marshaller; 1856| 1| va_marshaller = builtin_va_marshaller; 1857| 1| } 1858| 0| else 1859| 0| { 1860| 0| c_marshaller = g_cclosure_marshal_generic; 1861| 0| va_marshaller = g_cclosure_marshal_generic_va; 1862| 0| } 1863| 1| } 1864| 0| else 1865| 0| va_marshaller = NULL; 1866| | 1867| 1| node->c_marshaller = c_marshaller; 1868| 1| node->va_marshaller = va_marshaller; 1869| 1| node->emission_hooks = NULL; 1870| 1| if (class_closure) ------------------ | Branch (1870:7): [True: 1, False: 0] ------------------ 1871| 1| signal_add_class_closure (node, 0, class_closure); 1872| | 1873| 1| SIGNAL_UNLOCK (); ------------------ | | 329| 1|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 1|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 1|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 1874| | 1875| 1| g_free (signal_name_copy); 1876| | 1877| 1| return signal_id; 1878| 1|} g_signal_new_valist: 1960| 1|{ 1961| | /* Somewhat arbitrarily reserve 200 bytes. That should cover the majority 1962| | * of cases where n_params is small and still be small enough for what we 1963| | * want to put on the stack. */ 1964| 1| GType param_types_stack[200 / sizeof (GType)]; 1965| 1| GType *param_types_heap = NULL; 1966| 1| GType *param_types; 1967| 1| guint i; 1968| 1| guint signal_id; 1969| | 1970| 1| param_types = param_types_stack; 1971| 1| if (n_params > 0) ------------------ | Branch (1971:7): [True: 1, False: 0] ------------------ 1972| 1| { 1973| 1| if (G_UNLIKELY (n_params > G_N_ELEMENTS (param_types_stack))) ------------------ | | 1025| 1|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 1| int _g_boolean_var_; \ | | | | 1018| 1| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 1] | | | | ------------------ | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | 1020| 1| else \ | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | 1022| 1| _g_boolean_var_; \ | | | | 1023| 1|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 1] | | ------------------ ------------------ 1974| 0| { 1975| 0| param_types_heap = g_new (GType, n_params); ------------------ | | 290| 0|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 0| gsize __n = (gsize) (n_structs); \ | | | | 237| 0| gsize __s = sizeof (struct_type); \ | | | | 238| 0| gpointer __p; \ | | | | 239| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 0] | | | | ------------------ | | | | 240| 0| __p = g_##func (__n); \ | | | | 241| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 0| __p; \ | | | | 247| 0| })) | | ------------------ ------------------ 1976| 0| param_types = param_types_heap; 1977| 0| } 1978| | 1979| 2| for (i = 0; i < n_params; i++) ------------------ | Branch (1979:19): [True: 1, False: 1] ------------------ 1980| 1| param_types[i] = va_arg (args, GType); 1981| 1| } 1982| | 1983| 1| signal_id = g_signal_newv (signal_name, itype, signal_flags, 1984| 1| class_closure, accumulator, accu_data, c_marshaller, 1985| 1| return_type, n_params, param_types); 1986| 1| g_free (param_types_heap); 1987| | 1988| 1| return signal_id; 1989| 1|} g_signal_handlers_destroy: 2772| 15.4k|{ 2773| 15.4k| GBSearchArray *hlbsa; 2774| | 2775| 15.4k| g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance)); ------------------ | | 630| 15.4k| G_STMT_START { \ | | ------------------ | | | | 874| 15.4k|#define G_STMT_START do | | ------------------ | | 631| 15.4k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 15.4k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 15.4k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 15.4k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 15.4k| int _g_boolean_var_; \ | | | | | | 1018| 15.4k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 15.4k, False: 0] | | | | | | ------------------ | | | | | | 1019| 15.4k| _g_boolean_var_ = 1; \ | | | | | | 1020| 15.4k| else \ | | | | | | 1021| 15.4k| _g_boolean_var_ = 0; \ | | | | | | 1022| 15.4k| _g_boolean_var_; \ | | | | | | 1023| 15.4k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 15.4k, False: 0] | | | | ------------------ | | ------------------ | | 632| 15.4k| { } \ | | 633| 15.4k| else \ | | 634| 15.4k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 15.4k| } G_STMT_END | | ------------------ | | | | 882| 15.4k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 15.4k] | | | | ------------------ | | ------------------ ------------------ 2776| | 2777| 15.4k| SIGNAL_LOCK (); ------------------ | | 328| 15.4k|#define SIGNAL_LOCK() G_LOCK (g_signal_mutex) | | ------------------ | | | | 135| 15.4k|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 15.4k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 2778| 15.4k| hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance); 2779| 15.4k| if (hlbsa) ------------------ | Branch (2779:7): [True: 0, False: 15.4k] ------------------ 2780| 0| { 2781| 0| guint i; 2782| | 2783| | /* reentrancy caution, delete instance trace first */ 2784| 0| g_hash_table_remove (g_handler_list_bsa_ht, instance); 2785| | 2786| 0| for (i = 0; i < hlbsa->n_nodes; i++) ------------------ | Branch (2786:19): [True: 0, False: 0] ------------------ 2787| 0| { 2788| 0| HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, &g_signal_hlbsa_bconfig, i); 2789| 0| Handler *handler = hlist->handlers; 2790| | 2791| 0| while (handler) ------------------ | Branch (2791:18): [True: 0, False: 0] ------------------ 2792| 0| { 2793| 0| Handler *tmp = handler; 2794| | 2795| 0| handler = tmp->next; 2796| 0| tmp->block_count = 1; 2797| | /* cruel unlink, this works because _all_ handlers vanish */ 2798| 0| tmp->next = NULL; 2799| 0| tmp->prev = tmp; 2800| 0| if (tmp->sequential_number) ------------------ | Branch (2800:19): [True: 0, False: 0] ------------------ 2801| 0| { 2802| 0| g_hash_table_remove (g_handlers, tmp); 2803| 0| remove_invalid_closure_notify (tmp, instance); 2804| 0| tmp->sequential_number = 0; 2805| 0| handler_unref_R (0, NULL, tmp); 2806| 0| } 2807| 0| } 2808| 0| } 2809| 0| g_bsearch_array_free (hlbsa, &g_signal_hlbsa_bconfig); 2810| 0| } 2811| 15.4k| SIGNAL_UNLOCK (); ------------------ | | 329| 15.4k|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 15.4k|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 15.4k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 2812| 15.4k|} g_signal_emit_valist: 3269| 3.85k|{ 3270| 3.85k| GValue *instance_and_params; 3271| 3.85k| GType signal_return_type; 3272| 3.85k| GValue *param_values; 3273| 3.85k| SignalNode *node; 3274| 3.85k| guint i, n_params; 3275| | 3276| 3.85k| g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance)); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 3277| 3.85k| g_return_if_fail (signal_id > 0); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 3278| | 3279| 3.85k| SIGNAL_LOCK (); ------------------ | | 328| 3.85k|#define SIGNAL_LOCK() G_LOCK (g_signal_mutex) | | ------------------ | | | | 135| 3.85k|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3280| 3.85k| node = LOOKUP_SIGNAL_NODE (signal_id); 3281| 3.85k| if (!node || !g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype)) ------------------ | | 602| 3.85k|#define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class)) | | ------------------ | | | | 613| 3.85k|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) | | ------------------ ------------------ | Branch (3281:7): [True: 0, False: 3.85k] | Branch (3281:16): [True: 0, False: 3.85k] ------------------ 3282| 0| { 3283| 0| g_warning ("%s: signal id '%u' is invalid for instance '%p'", G_STRLOC, signal_id, instance); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3284| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3285| 0| return; 3286| 0| } 3287| 3.85k|#ifndef G_DISABLE_CHECKS 3288| 3.85k| if (detail && !(node->flags & G_SIGNAL_DETAILED)) ------------------ | Branch (3288:7): [True: 3.85k, False: 0] | Branch (3288:17): [True: 0, False: 3.85k] ------------------ 3289| 0| { 3290| 0| g_warning ("%s: signal id '%u' does not support detail (%u)", G_STRLOC, signal_id, detail); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3291| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3292| 0| return; 3293| 0| } 3294| 3.85k|#endif /* !G_DISABLE_CHECKS */ 3295| | 3296| 3.85k| if (!node->single_va_closure_is_valid) ------------------ | Branch (3296:7): [True: 1, False: 3.85k] ------------------ 3297| 1| node_update_single_va_closure (node); 3298| | 3299| 3.85k| if (node->single_va_closure != NULL) ------------------ | Branch (3299:7): [True: 3.85k, False: 0] ------------------ 3300| 3.85k| { 3301| 3.85k| HandlerList* hlist; 3302| 3.85k| Handler *fastpath_handler = NULL; 3303| 3.85k| Handler *l; 3304| 3.85k| GClosure *closure = NULL; 3305| 3.85k| gboolean fastpath = TRUE; ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 3306| 3.85k| GSignalFlags run_type = G_SIGNAL_RUN_FIRST; 3307| | 3308| 3.85k| if (node->single_va_closure != SINGLE_VA_CLOSURE_EMPTY_MAGIC && ------------------ | | 250| 3.85k|#define SINGLE_VA_CLOSURE_EMPTY_MAGIC GINT_TO_POINTER(1) /* indicates single_va_closure is valid but empty */ | | ------------------ | | | | 101| 7.70k|#define GINT_TO_POINTER(i) ((gpointer) (glong) (i)) | | ------------------ ------------------ | Branch (3308:11): [True: 3.85k, False: 0] ------------------ 3309| 3.85k| !_g_closure_is_void (node->single_va_closure, instance)) ------------------ | Branch (3309:4): [True: 0, False: 3.85k] ------------------ 3310| 0| { 3311| 0| if (_g_closure_supports_invoke_va (node->single_va_closure)) ------------------ | Branch (3311:8): [True: 0, False: 0] ------------------ 3312| 0| { 3313| 0| closure = node->single_va_closure; 3314| 0| if (node->single_va_closure_is_after) ------------------ | Branch (3314:12): [True: 0, False: 0] ------------------ 3315| 0| run_type = G_SIGNAL_RUN_LAST; 3316| 0| else 3317| 0| run_type = G_SIGNAL_RUN_FIRST; 3318| 0| } 3319| 0| else 3320| 0| fastpath = FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 3321| 0| } 3322| | 3323| | /* single_va_closure is only true for GObjects, so fast path if no handler ever connected to the signal */ 3324| 3.85k| if (_g_object_has_signal_handler ((GObject *)instance)) ------------------ | Branch (3324:11): [True: 0, False: 3.85k] ------------------ 3325| 0| hlist = handler_list_lookup (node->signal_id, instance); 3326| 3.85k| else 3327| 3.85k| hlist = NULL; 3328| | 3329| 3.85k| for (l = hlist ? hlist->handlers : NULL; fastpath && l != NULL; l = l->next) ------------------ | Branch (3329:16): [True: 0, False: 3.85k] | Branch (3329:48): [True: 3.85k, False: 0] | Branch (3329:60): [True: 0, False: 3.85k] ------------------ 3330| 0| { 3331| 0| if (!l->block_count && ------------------ | Branch (3331:8): [True: 0, False: 0] ------------------ 3332| 0| (!l->detail || l->detail == detail)) ------------------ | Branch (3332:9): [True: 0, False: 0] | Branch (3332:23): [True: 0, False: 0] ------------------ 3333| 0| { 3334| 0| if (closure != NULL || !_g_closure_supports_invoke_va (l->closure)) ------------------ | Branch (3334:12): [True: 0, False: 0] | Branch (3334:31): [True: 0, False: 0] ------------------ 3335| 0| { 3336| 0| fastpath = FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 3337| 0| break; 3338| 0| } 3339| 0| else 3340| 0| { 3341| 0| fastpath_handler = l; 3342| 0| closure = l->closure; 3343| 0| if (l->after) ------------------ | Branch (3343:9): [True: 0, False: 0] ------------------ 3344| 0| run_type = G_SIGNAL_RUN_LAST; 3345| 0| else 3346| 0| run_type = G_SIGNAL_RUN_FIRST; 3347| 0| } 3348| 0| } 3349| 0| } 3350| | 3351| 3.85k| if (fastpath && closure == NULL && node->return_type == G_TYPE_NONE) ------------------ | | 62| 3.85k|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 3.85k|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 3.85k|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (3351:11): [True: 3.85k, False: 0] | Branch (3351:23): [True: 3.85k, False: 0] | Branch (3351:42): [True: 3.85k, False: 0] ------------------ 3352| 3.85k| { 3353| 3.85k| SIGNAL_UNLOCK (); ------------------ | | 329| 3.85k|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 3.85k|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 3.85k|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3354| 3.85k| return; 3355| 3.85k| } 3356| | 3357| | /* Don't allow no-recurse emission as we might have to restart, which means 3358| | we will run multiple handlers and thus must ref all arguments */ 3359| 0| if (closure != NULL && (node->flags & (G_SIGNAL_NO_RECURSE)) != 0) ------------------ | Branch (3359:11): [True: 0, False: 0] | Branch (3359:30): [True: 0, False: 0] ------------------ 3360| 0| fastpath = FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 3361| | 3362| 0| if (fastpath) ------------------ | Branch (3362:11): [True: 0, False: 0] ------------------ 3363| 0| { 3364| 0| SignalAccumulator *accumulator; 3365| 0| Emission emission; 3366| 0| GValue *return_accu, accu = G_VALUE_INIT; ------------------ | | 202| 0|#define G_VALUE_INIT { 0, { { 0 } } } ------------------ 3367| 0| guint signal_id; 3368| 0| GType instance_type = G_TYPE_FROM_INSTANCE (instance); ------------------ | | 602| 0|#define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class)) | | ------------------ | | | | 613| 0|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) | | ------------------ ------------------ 3369| 0| GValue emission_return = G_VALUE_INIT; ------------------ | | 202| 0|#define G_VALUE_INIT { 0, { { 0 } } } ------------------ 3370| 0| GType rtype = node->return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE; ------------------ | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ 3371| 0| gboolean static_scope = node->return_type & G_SIGNAL_TYPE_STATIC_SCOPE; ------------------ | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ 3372| | 3373| 0| signal_id = node->signal_id; 3374| 0| accumulator = node->accumulator; 3375| 0| if (rtype == G_TYPE_NONE) ------------------ | | 62| 0|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (3375:8): [True: 0, False: 0] ------------------ 3376| 0| return_accu = NULL; 3377| 0| else if (accumulator) ------------------ | Branch (3377:13): [True: 0, False: 0] ------------------ 3378| 0| return_accu = &accu; 3379| 0| else 3380| 0| return_accu = &emission_return; 3381| | 3382| 0| emission.instance = instance; 3383| 0| emission.ihint.signal_id = signal_id; 3384| 0| emission.ihint.detail = detail; 3385| 0| emission.ihint.run_type = run_type | G_SIGNAL_ACCUMULATOR_FIRST_RUN; 3386| 0| emission.state = EMISSION_RUN; 3387| 0| emission.chain_type = instance_type; 3388| 0| emission_push (&emission); 3389| | 3390| 0| if (fastpath_handler) ------------------ | Branch (3390:15): [True: 0, False: 0] ------------------ 3391| 0| handler_ref (fastpath_handler); 3392| | 3393| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3394| | 3395| 0| TRACE(GOBJECT_SIGNAL_EMIT(signal_id, detail, instance, instance_type)); 3396| | 3397| 0| if (rtype != G_TYPE_NONE) ------------------ | | 62| 0|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (3397:8): [True: 0, False: 0] ------------------ 3398| 0| g_value_init (&emission_return, rtype); 3399| | 3400| 0| if (accumulator) ------------------ | Branch (3400:8): [True: 0, False: 0] ------------------ 3401| 0| g_value_init (&accu, rtype); 3402| | 3403| 0| if (closure != NULL) ------------------ | Branch (3403:8): [True: 0, False: 0] ------------------ 3404| 0| { 3405| 0| g_object_ref (instance); ------------------ | | 523| 0|#define g_object_ref(Obj) ((glib_typeof (Obj)) (g_object_ref) (Obj)) ------------------ 3406| 0| _g_closure_invoke_va (closure, 3407| 0| return_accu, 3408| 0| instance, 3409| 0| var_args, 3410| 0| node->n_params, 3411| 0| node->param_types); 3412| 0| accumulate (&emission.ihint, &emission_return, &accu, accumulator); 3413| 0| } 3414| | 3415| 0| SIGNAL_LOCK (); ------------------ | | 328| 0|#define SIGNAL_LOCK() G_LOCK (g_signal_mutex) | | ------------------ | | | | 135| 0|# define G_LOCK(name) g_mutex_lock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3416| | 3417| 0| emission.chain_type = G_TYPE_NONE; ------------------ | | 62| 0|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 3418| 0| emission_pop (&emission); 3419| | 3420| 0| if (fastpath_handler) ------------------ | Branch (3420:15): [True: 0, False: 0] ------------------ 3421| 0| handler_unref_R (signal_id, instance, fastpath_handler); 3422| | 3423| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3424| | 3425| 0| if (accumulator) ------------------ | Branch (3425:8): [True: 0, False: 0] ------------------ 3426| 0| g_value_unset (&accu); 3427| | 3428| 0| if (rtype != G_TYPE_NONE) ------------------ | | 62| 0|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (3428:8): [True: 0, False: 0] ------------------ 3429| 0| { 3430| 0| gchar *error = NULL; 3431| 0| for (i = 0; i < node->n_params; i++) ------------------ | Branch (3431:20): [True: 0, False: 0] ------------------ 3432| 0| { 3433| 0| GType ptype = node->param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE; ------------------ | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ 3434| 0| G_VALUE_COLLECT_SKIP (ptype, var_args); ------------------ | | 166| 0|#define G_VALUE_COLLECT_SKIP(_value_type, var_args) \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 167| 0|G_STMT_START { \ | | 168| 0| GTypeValueTable *g_vcs_vtable = g_type_value_table_peek (_value_type); \ | | 169| 0| const gchar *g_vcs_collect_format = g_vcs_vtable->collect_format; \ | | 170| 0| \ | | 171| 0| while (*g_vcs_collect_format) \ | | ------------------ | | | Branch (171:10): [True: 0, False: 0] | | ------------------ | | 172| 0| { \ | | 173| 0| switch (*g_vcs_collect_format++) \ | | 174| 0| { \ | | 175| 0| case G_VALUE_COLLECT_INT: \ | | ------------------ | | | Branch (175:2): [True: 0, False: 0] | | ------------------ | | 176| 0| va_arg ((var_args), gint); \ | | 177| 0| break; \ | | 178| 0| case G_VALUE_COLLECT_LONG: \ | | ------------------ | | | Branch (178:2): [True: 0, False: 0] | | ------------------ | | 179| 0| va_arg ((var_args), glong); \ | | 180| 0| break; \ | | 181| 0| case G_VALUE_COLLECT_INT64: \ | | ------------------ | | | Branch (181:2): [True: 0, False: 0] | | ------------------ | | 182| 0| va_arg ((var_args), gint64); \ | | 183| 0| break; \ | | 184| 0| case G_VALUE_COLLECT_DOUBLE: \ | | ------------------ | | | Branch (184:2): [True: 0, False: 0] | | ------------------ | | 185| 0| va_arg ((var_args), gdouble); \ | | 186| 0| break; \ | | 187| 0| case G_VALUE_COLLECT_POINTER: \ | | ------------------ | | | Branch (187:2): [True: 0, False: 0] | | ------------------ | | 188| 0| va_arg ((var_args), gpointer); \ | | 189| 0| break; \ | | 190| 0| default: \ | | ------------------ | | | Branch (190:2): [True: 0, False: 0] | | ------------------ | | 191| 0| g_assert_not_reached (); \ | | ------------------ | | | | 230| 0|#define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 192| 0| } \ | | 193| 0| } \ | | 194| 0|} G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3435| 0| } 3436| | 3437| 0| G_VALUE_LCOPY (&emission_return, ------------------ | | 209| 0|#define G_VALUE_LCOPY(value, var_args, flags, __error) \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 210| 0|G_STMT_START { \ | | 211| 0| const GValue *g_vl_value = (value); \ | | 212| 0| guint g_vl_flags = (flags); \ | | ------------------ | | | Branch (212:23): [True: 0, False: 0] | | ------------------ | | 213| 0| GType g_vl_value_type = G_VALUE_TYPE (g_vl_value); \ | | ------------------ | | | | 59| 0|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) | | ------------------ | | 214| 0| GTypeValueTable *g_vl_vtable = g_type_value_table_peek (g_vl_value_type); \ | | 215| 0| const gchar *g_vl_lcopy_format = g_vl_vtable->lcopy_format; \ | | 216| 0| GTypeCValue g_vl_cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, }; \ | | 217| 0| guint g_vl_n_values = 0; \ | | 218| 0| \ | | 219| 0| while (*g_vl_lcopy_format) \ | | ------------------ | | | Branch (219:10): [True: 0, False: 0] | | ------------------ | | 220| 0| { \ | | 221| 0| GTypeCValue *g_vl_cvalue = g_vl_cvalues + g_vl_n_values++; \ | | 222| 0| \ | | 223| 0| switch (*g_vl_lcopy_format++) \ | | 224| 0| { \ | | 225| 0| case G_VALUE_COLLECT_INT: \ | | ------------------ | | | Branch (225:2): [True: 0, False: 0] | | ------------------ | | 226| 0| g_vl_cvalue->v_int = va_arg ((var_args), gint); \ | | 227| 0| break; \ | | 228| 0| case G_VALUE_COLLECT_LONG: \ | | ------------------ | | | Branch (228:2): [True: 0, False: 0] | | ------------------ | | 229| 0| g_vl_cvalue->v_long = va_arg ((var_args), glong); \ | | 230| 0| break; \ | | 231| 0| case G_VALUE_COLLECT_INT64: \ | | ------------------ | | | Branch (231:2): [True: 0, False: 0] | | ------------------ | | 232| 0| g_vl_cvalue->v_int64 = va_arg ((var_args), gint64); \ | | 233| 0| break; \ | | 234| 0| case G_VALUE_COLLECT_DOUBLE: \ | | ------------------ | | | Branch (234:2): [True: 0, False: 0] | | ------------------ | | 235| 0| g_vl_cvalue->v_double = va_arg ((var_args), gdouble); \ | | 236| 0| break; \ | | 237| 0| case G_VALUE_COLLECT_POINTER: \ | | ------------------ | | | Branch (237:2): [True: 0, False: 0] | | ------------------ | | 238| 0| g_vl_cvalue->v_pointer = va_arg ((var_args), gpointer); \ | | 239| 0| break; \ | | 240| 0| default: \ | | ------------------ | | | Branch (240:2): [True: 0, False: 0] | | ------------------ | | 241| 0| g_assert_not_reached (); \ | | ------------------ | | | | 230| 0|#define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 242| 0| } \ | | 243| 0| } \ | | 244| 0| *(__error) = g_vl_vtable->lcopy_value (g_vl_value, \ | | 245| 0| g_vl_n_values, \ | | 246| 0| g_vl_cvalues, \ | | 247| 0| g_vl_flags); \ | | 248| 0|} G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3438| 0| var_args, 3439| 0| static_scope ? G_VALUE_NOCOPY_CONTENTS : 0, 3440| 0| &error); 3441| 0| if (!error) ------------------ | Branch (3441:12): [True: 0, False: 0] ------------------ 3442| 0| g_value_unset (&emission_return); 3443| 0| else 3444| 0| { 3445| 0| g_warning ("%s: %s", G_STRLOC, error); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3446| 0| g_free (error); 3447| | /* we purposely leak the value here, it might not be 3448| | * in a correct state if an error condition occurred 3449| | */ 3450| 0| } 3451| 0| } 3452| | 3453| 0| TRACE(GOBJECT_SIGNAL_EMIT_END(signal_id, detail, instance, instance_type)); 3454| | 3455| 0| if (closure != NULL) ------------------ | Branch (3455:15): [True: 0, False: 0] ------------------ 3456| 0| g_object_unref (instance); 3457| | 3458| 0| return; 3459| 0| } 3460| 0| } 3461| 0| SIGNAL_UNLOCK (); ------------------ | | 329| 0|#define SIGNAL_UNLOCK() G_UNLOCK (g_signal_mutex) | | ------------------ | | | | 136| 0|# define G_UNLOCK(name) g_mutex_unlock (&G_LOCK_NAME (name)) | | | | ------------------ | | | | | | 109| 0|#define G_LOCK_NAME(name) g__ ## name ## _lock | | | | ------------------ | | ------------------ ------------------ 3462| | 3463| 0| n_params = node->n_params; 3464| 0| signal_return_type = node->return_type; 3465| 0| instance_and_params = g_alloca (sizeof (GValue) * (n_params + 1)); ------------------ | | 91| 0|#define g_alloca(size) alloca (size) ------------------ 3466| 0| memset (instance_and_params, 0, sizeof (GValue) * (n_params + 1)); 3467| 0| param_values = instance_and_params + 1; 3468| | 3469| 0| for (i = 0; i < node->n_params; i++) ------------------ | Branch (3469:15): [True: 0, False: 0] ------------------ 3470| 0| { 3471| 0| gchar *error; 3472| 0| GType ptype = node->param_types[i] & ~G_SIGNAL_TYPE_STATIC_SCOPE; ------------------ | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ 3473| 0| gboolean static_scope = node->param_types[i] & G_SIGNAL_TYPE_STATIC_SCOPE; ------------------ | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ 3474| | 3475| 0| G_VALUE_COLLECT_INIT (param_values + i, ptype, ------------------ | | 88| 0|#define G_VALUE_COLLECT_INIT(value, _value_type, var_args, flags, __error) \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 89| 0|G_STMT_START { \ | | 90| 0| GValue *g_vci_val = (value); \ | | 91| 0| guint g_vci_flags = (flags); \ | | ------------------ | | | Branch (91:24): [True: 0, False: 0] | | ------------------ | | 92| 0| GTypeValueTable *g_vci_vtab = g_type_value_table_peek (_value_type); \ | | 93| 0| const gchar *g_vci_collect_format = g_vci_vtab->collect_format; \ | | 94| 0| GTypeCValue g_vci_cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, }; \ | | 95| 0| guint g_vci_n_values = 0; \ | | 96| 0| \ | | 97| 0| g_vci_val->g_type = _value_type; /* value_meminit() from gvalue.c */ \ | | 98| 0| while (*g_vci_collect_format) \ | | ------------------ | | | Branch (98:10): [True: 0, False: 0] | | ------------------ | | 99| 0| { \ | | 100| 0| GTypeCValue *g_vci_cvalue = g_vci_cvalues + g_vci_n_values++; \ | | 101| 0| \ | | 102| 0| switch (*g_vci_collect_format++) \ | | 103| 0| { \ | | 104| 0| case G_VALUE_COLLECT_INT: \ | | ------------------ | | | Branch (104:2): [True: 0, False: 0] | | ------------------ | | 105| 0| g_vci_cvalue->v_int = va_arg ((var_args), gint); \ | | 106| 0| break; \ | | 107| 0| case G_VALUE_COLLECT_LONG: \ | | ------------------ | | | Branch (107:2): [True: 0, False: 0] | | ------------------ | | 108| 0| g_vci_cvalue->v_long = va_arg ((var_args), glong); \ | | 109| 0| break; \ | | 110| 0| case G_VALUE_COLLECT_INT64: \ | | ------------------ | | | Branch (110:2): [True: 0, False: 0] | | ------------------ | | 111| 0| g_vci_cvalue->v_int64 = va_arg ((var_args), gint64); \ | | 112| 0| break; \ | | 113| 0| case G_VALUE_COLLECT_DOUBLE: \ | | ------------------ | | | Branch (113:2): [True: 0, False: 0] | | ------------------ | | 114| 0| g_vci_cvalue->v_double = va_arg ((var_args), gdouble); \ | | 115| 0| break; \ | | 116| 0| case G_VALUE_COLLECT_POINTER: \ | | ------------------ | | | Branch (116:2): [True: 0, False: 0] | | ------------------ | | 117| 0| g_vci_cvalue->v_pointer = va_arg ((var_args), gpointer); \ | | 118| 0| break; \ | | 119| 0| default: \ | | ------------------ | | | Branch (119:2): [True: 0, False: 0] | | ------------------ | | 120| 0| g_assert_not_reached (); \ | | ------------------ | | | | 230| 0|#define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 121| 0| } \ | | 122| 0| } \ | | 123| 0| *(__error) = g_vci_vtab->collect_value (g_vci_val, \ | | 124| 0| g_vci_n_values, \ | | 125| 0| g_vci_cvalues, \ | | 126| 0| g_vci_flags); \ | | 127| 0|} G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3476| 0| var_args, 3477| 0| static_scope ? G_VALUE_NOCOPY_CONTENTS : 0, 3478| 0| &error); 3479| 0| if (error) ------------------ | Branch (3479:11): [True: 0, False: 0] ------------------ 3480| 0| { 3481| 0| g_warning ("%s: %s", G_STRLOC, error); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3482| 0| g_free (error); 3483| | 3484| | /* we purposely leak the value here, it might not be 3485| | * in a correct state if an error condition occurred 3486| | */ 3487| 0| while (i--) ------------------ | Branch (3487:11): [True: 0, False: 0] ------------------ 3488| 0| g_value_unset (param_values + i); 3489| | 3490| 0| return; 3491| 0| } 3492| 0| } 3493| | 3494| 0| instance_and_params->g_type = 0; 3495| 0| g_value_init_from_instance (instance_and_params, instance); 3496| 0| if (signal_return_type == G_TYPE_NONE) ------------------ | | 62| 0|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ | Branch (3496:7): [True: 0, False: 0] ------------------ 3497| 0| signal_emit_unlocked_R (node, detail, instance, NULL, instance_and_params); 3498| 0| else 3499| 0| { 3500| 0| GValue return_value = G_VALUE_INIT; ------------------ | | 202| 0|#define G_VALUE_INIT { 0, { { 0 } } } ------------------ 3501| 0| gchar *error = NULL; 3502| 0| GType rtype = signal_return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE; ------------------ | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ 3503| 0| gboolean static_scope = signal_return_type & G_SIGNAL_TYPE_STATIC_SCOPE; ------------------ | | 213| 0|#define G_SIGNAL_TYPE_STATIC_SCOPE (G_TYPE_FLAG_RESERVED_ID_BIT) | | ------------------ | | | | 2353| 0|#define G_TYPE_FLAG_RESERVED_ID_BIT ((GType) (1 << 0)) | | ------------------ ------------------ 3504| | 3505| 0| g_value_init (&return_value, rtype); 3506| | 3507| 0| signal_emit_unlocked_R (node, detail, instance, &return_value, instance_and_params); 3508| | 3509| 0| G_VALUE_LCOPY (&return_value, ------------------ | | 209| 0|#define G_VALUE_LCOPY(value, var_args, flags, __error) \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 210| 0|G_STMT_START { \ | | 211| 0| const GValue *g_vl_value = (value); \ | | 212| 0| guint g_vl_flags = (flags); \ | | ------------------ | | | Branch (212:23): [True: 0, False: 0] | | ------------------ | | 213| 0| GType g_vl_value_type = G_VALUE_TYPE (g_vl_value); \ | | ------------------ | | | | 59| 0|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) | | ------------------ | | 214| 0| GTypeValueTable *g_vl_vtable = g_type_value_table_peek (g_vl_value_type); \ | | 215| 0| const gchar *g_vl_lcopy_format = g_vl_vtable->lcopy_format; \ | | 216| 0| GTypeCValue g_vl_cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, }; \ | | 217| 0| guint g_vl_n_values = 0; \ | | 218| 0| \ | | 219| 0| while (*g_vl_lcopy_format) \ | | ------------------ | | | Branch (219:10): [True: 0, False: 0] | | ------------------ | | 220| 0| { \ | | 221| 0| GTypeCValue *g_vl_cvalue = g_vl_cvalues + g_vl_n_values++; \ | | 222| 0| \ | | 223| 0| switch (*g_vl_lcopy_format++) \ | | 224| 0| { \ | | 225| 0| case G_VALUE_COLLECT_INT: \ | | ------------------ | | | Branch (225:2): [True: 0, False: 0] | | ------------------ | | 226| 0| g_vl_cvalue->v_int = va_arg ((var_args), gint); \ | | 227| 0| break; \ | | 228| 0| case G_VALUE_COLLECT_LONG: \ | | ------------------ | | | Branch (228:2): [True: 0, False: 0] | | ------------------ | | 229| 0| g_vl_cvalue->v_long = va_arg ((var_args), glong); \ | | 230| 0| break; \ | | 231| 0| case G_VALUE_COLLECT_INT64: \ | | ------------------ | | | Branch (231:2): [True: 0, False: 0] | | ------------------ | | 232| 0| g_vl_cvalue->v_int64 = va_arg ((var_args), gint64); \ | | 233| 0| break; \ | | 234| 0| case G_VALUE_COLLECT_DOUBLE: \ | | ------------------ | | | Branch (234:2): [True: 0, False: 0] | | ------------------ | | 235| 0| g_vl_cvalue->v_double = va_arg ((var_args), gdouble); \ | | 236| 0| break; \ | | 237| 0| case G_VALUE_COLLECT_POINTER: \ | | ------------------ | | | Branch (237:2): [True: 0, False: 0] | | ------------------ | | 238| 0| g_vl_cvalue->v_pointer = va_arg ((var_args), gpointer); \ | | 239| 0| break; \ | | 240| 0| default: \ | | ------------------ | | | Branch (240:2): [True: 0, False: 0] | | ------------------ | | 241| 0| g_assert_not_reached (); \ | | ------------------ | | | | 230| 0|#define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | | | ------------------ | | | | #define g_assert_not_reached() G_STMT_START { g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 242| 0| } \ | | 243| 0| } \ | | 244| 0| *(__error) = g_vl_vtable->lcopy_value (g_vl_value, \ | | 245| 0| g_vl_n_values, \ | | 246| 0| g_vl_cvalues, \ | | 247| 0| g_vl_flags); \ | | 248| 0|} G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 3510| 0| var_args, 3511| 0| static_scope ? G_VALUE_NOCOPY_CONTENTS : 0, 3512| 0| &error); 3513| 0| if (!error) ------------------ | Branch (3513:11): [True: 0, False: 0] ------------------ 3514| 0| g_value_unset (&return_value); 3515| 0| else 3516| 0| { 3517| 0| g_warning ("%s: %s", G_STRLOC, error); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3518| 0| g_free (error); 3519| | 3520| | /* we purposely leak the value here, it might not be 3521| | * in a correct state if an error condition occurred 3522| | */ 3523| 0| } 3524| 0| } 3525| 0| for (i = 0; i < n_params; i++) ------------------ | Branch (3525:15): [True: 0, False: 0] ------------------ 3526| 0| g_value_unset (param_values + i); 3527| 0| g_value_unset (instance_and_params); 3528| 0|} g_signal_emit: 3549| 3.85k|{ 3550| 3.85k| va_list var_args; 3551| | 3552| 3.85k| va_start (var_args, detail); 3553| 3.85k| g_signal_emit_valist (instance, signal_id, detail, var_args); 3554| | va_end (var_args); 3555| 3.85k|} gsignal.c:LOOKUP_SIGNAL_NODE: 338| 3.85k|{ 339| 3.85k| if (signal_id < g_n_signal_nodes) ------------------ | Branch (339:7): [True: 3.85k, False: 0] ------------------ 340| 3.85k| return g_signal_nodes[signal_id]; 341| 0| else 342| 0| return NULL; 343| 3.85k|} gsignal.c:signal_id_lookup: 398| 1|{ 399| 1| GQuark quark; 400| 1| GType *ifaces, type = itype; 401| 1| SignalKey key; 402| 1| guint n_ifaces; 403| | 404| 1| quark = g_quark_try_string (name); 405| 1| key.quark = quark; 406| | 407| | /* try looking up signals for this type and its ancestors */ 408| 1| do 409| 1| { 410| 1| SignalKey *signal_key; 411| | 412| 1| key.itype = type; 413| 1| signal_key = g_bsearch_array_lookup (g_signal_key_bsa, &g_signal_key_bconfig, &key); ------------------ | | 97| 1| g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 0) ------------------ 414| | 415| 1| if (signal_key) ------------------ | Branch (415:11): [True: 0, False: 1] ------------------ 416| 0| return signal_key->signal_id; 417| | 418| 1| type = g_type_parent (type); 419| 1| } 420| 1| while (type); ------------------ | Branch (420:10): [True: 0, False: 1] ------------------ 421| | 422| | /* no luck, try interfaces it exports */ 423| 1| ifaces = g_type_interfaces (itype, &n_ifaces); 424| 1| while (n_ifaces--) ------------------ | Branch (424:10): [True: 0, False: 1] ------------------ 425| 0| { 426| 0| SignalKey *signal_key; 427| | 428| 0| key.itype = ifaces[n_ifaces]; 429| 0| signal_key = g_bsearch_array_lookup (g_signal_key_bsa, &g_signal_key_bconfig, &key); ------------------ | | 97| 0| g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 0) ------------------ 430| | 431| 0| if (signal_key) ------------------ | Branch (431:11): [True: 0, False: 0] ------------------ 432| 0| { 433| 0| g_free (ifaces); 434| 0| return signal_key->signal_id; 435| 0| } 436| 0| } 437| 1| g_free (ifaces); 438| | 439| | /* If the @name is non-canonical, try again. This is the slow path — people 440| | * should use canonical names in their queries if they want performance. */ 441| 1| if (!is_canonical (name)) ------------------ | Branch (441:7): [True: 0, False: 1] ------------------ 442| 0| { 443| 0| guint signal_id; 444| 0| gchar *name_copy = g_strdup (name); 445| 0| canonicalize_key (name_copy); 446| | 447| 0| signal_id = signal_id_lookup (name_copy, itype); 448| | 449| 0| g_free (name_copy); 450| | 451| 0| return signal_id; 452| 0| } 453| | 454| 1| return 0; 455| 1|} gsignal.c:is_canonical: 366| 2|{ 367| | return (strchr (key, '_') == NULL); 368| 2|} gsignal.c:signal_add_class_closure: 1639| 1|{ 1640| 1| ClassClosure key; 1641| | 1642| 1| node->single_va_closure_is_valid = FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 1643| | 1644| 1| if (!node->class_closure_bsa) ------------------ | Branch (1644:7): [True: 1, False: 0] ------------------ 1645| 1| node->class_closure_bsa = g_bsearch_array_create (&g_class_closure_bconfig); 1646| 1| key.instance_type = itype; 1647| 1| key.closure = g_closure_ref (closure); 1648| 1| node->class_closure_bsa = g_bsearch_array_insert (node->class_closure_bsa, 1649| 1| &g_class_closure_bconfig, 1650| 1| &key); 1651| 1| g_closure_sink (closure); 1652| 1| if (node->c_marshaller && closure && G_CLOSURE_NEEDS_MARSHAL (closure)) ------------------ | | 39| 1|#define G_CLOSURE_NEEDS_MARSHAL(closure) (((GClosure*) (closure))->marshal == NULL) | | ------------------ | | | Branch (39:42): [True: 1, False: 0] | | ------------------ ------------------ | Branch (1652:7): [True: 1, False: 0] | Branch (1652:29): [True: 1, False: 0] ------------------ 1653| 1| { 1654| 1| g_closure_set_marshal (closure, node->c_marshaller); 1655| 1| if (node->va_marshaller) ------------------ | Branch (1655:11): [True: 1, False: 0] ------------------ 1656| 1| _g_closure_set_va_marshal (closure, node->va_marshaller); 1657| 1| } 1658| 1|} gsignal.c:node_update_single_va_closure: 822| 1|{ 823| 1| GClosure *closure = NULL; 824| 1| gboolean is_after = FALSE; ------------------ | | 814| 1|#define FALSE (0) ------------------ 825| | 826| | /* Fast path single-handler without boxing the arguments in GValues */ 827| 1| if (G_TYPE_IS_OBJECT (node->itype) && ------------------ | | 47| 2|#define G_TYPE_IS_OBJECT(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_OBJECT) | | ------------------ | | | | 38| 1|#define G_TYPE_FUNDAMENTAL(type) (g_type_fundamental (type)) | | ------------------ | | #define G_TYPE_IS_OBJECT(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_OBJECT) | | ------------------ | | | | 178| 1|#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20) | | | | ------------------ | | | | | | 221| 1|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 1|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (47:37): [True: 1, False: 0] | | ------------------ ------------------ 828| 1| (node->flags & (G_SIGNAL_MUST_COLLECT)) == 0 && ------------------ | Branch (828:7): [True: 1, False: 0] ------------------ 829| 1| (node->emission_hooks == NULL || node->emission_hooks->hooks == NULL)) ------------------ | Branch (829:8): [True: 1, False: 0] | Branch (829:40): [True: 0, False: 0] ------------------ 830| 1| { 831| 1| GSignalFlags run_type; 832| 1| ClassClosure * cc; 833| 1| GBSearchArray *bsa = node->class_closure_bsa; 834| | 835| 1| if (bsa == NULL || bsa->n_nodes == 0) ------------------ | Branch (835:11): [True: 0, False: 1] | Branch (835:26): [True: 0, False: 1] ------------------ 836| 0| closure = SINGLE_VA_CLOSURE_EMPTY_MAGIC; ------------------ | | 250| 0|#define SINGLE_VA_CLOSURE_EMPTY_MAGIC GINT_TO_POINTER(1) /* indicates single_va_closure is valid but empty */ | | ------------------ | | | | 101| 0|#define GINT_TO_POINTER(i) ((gpointer) (glong) (i)) | | ------------------ ------------------ 837| 1| else if (bsa->n_nodes == 1) ------------------ | Branch (837:16): [True: 1, False: 0] ------------------ 838| 1| { 839| | /* Look for default class closure (can't support non-default as it 840| | chains up using GValues */ 841| 1| cc = g_bsearch_array_get_nth (bsa, &g_class_closure_bconfig, 0); 842| 1| if (cc->instance_type == 0) ------------------ | Branch (842:8): [True: 1, False: 0] ------------------ 843| 1| { 844| 1| run_type = node->flags & (G_SIGNAL_RUN_FIRST|G_SIGNAL_RUN_LAST|G_SIGNAL_RUN_CLEANUP); 845| | /* Only support *one* of run-first or run-last, not multiple or cleanup */ 846| 1| if (run_type == G_SIGNAL_RUN_FIRST || ------------------ | Branch (846:12): [True: 1, False: 0] ------------------ 847| 0| run_type == G_SIGNAL_RUN_LAST) ------------------ | Branch (847:5): [True: 0, False: 0] ------------------ 848| 1| { 849| 1| closure = cc->closure; 850| 1| is_after = (run_type == G_SIGNAL_RUN_LAST); 851| 1| } 852| 1| } 853| 1| } 854| 1| } 855| | 856| 1| node->single_va_closure_is_valid = TRUE; ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 857| 1| node->single_va_closure = closure; 858| 1| node->single_va_closure_is_after = is_after; 859| 1|} g_type_interface_add_prerequisite: 1565| 3|{ 1566| 3| TypeNode *iface, *prerequisite_node; 1567| 3| IFaceHolder *holders; 1568| | 1569| 3| g_return_if_fail (G_TYPE_IS_INTERFACE (interface_type)); /* G_TYPE_IS_INTERFACE() is an external call: _U */ ------------------ | | 630| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 631| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 632| 3| { } \ | | 633| 3| else \ | | 634| 3| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1570| 3| g_return_if_fail (!g_type_is_a (interface_type, prerequisite_type)); ------------------ | | 630| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 631| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 632| 3| { } \ | | 633| 3| else \ | | 634| 3| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1571| 3| g_return_if_fail (!g_type_is_a (prerequisite_type, interface_type)); ------------------ | | 630| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 631| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 632| 3| { } \ | | 633| 3| else \ | | 634| 3| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1572| | 1573| 3| iface = lookup_type_node_I (interface_type); 1574| 3| prerequisite_node = lookup_type_node_I (prerequisite_type); 1575| 3| if (!iface || !prerequisite_node || !NODE_IS_IFACE (iface)) ------------------ | | 258| 3|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 3|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 3|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 3|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 3|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1575:7): [True: 0, False: 3] | Branch (1575:17): [True: 0, False: 3] | Branch (1575:39): [True: 0, False: 3] ------------------ 1576| 0| { 1577| 0| g_warning ("interface type '%s' or prerequisite type '%s' invalid", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1578| 0| type_descriptive_name_I (interface_type), 1579| 0| type_descriptive_name_I (prerequisite_type)); 1580| 0| return; 1581| 0| } 1582| 3| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 3|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 1583| 3| holders = iface_node_get_holders_L (iface); ------------------ | | 263| 3|#define iface_node_get_holders_L(node) ((IFaceHolder*) type_get_qdata_L ((node), static_quark_iface_holder)) ------------------ 1584| 3| if (holders) ------------------ | Branch (1584:7): [True: 0, False: 3] ------------------ 1585| 0| { 1586| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 1587| 0| g_warning ("unable to add prerequisite '%s' to interface '%s' which is already in use for '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1588| 0| type_descriptive_name_I (prerequisite_type), 1589| 0| type_descriptive_name_I (interface_type), 1590| 0| type_descriptive_name_I (holders->instance_type)); 1591| 0| return; 1592| 0| } 1593| 3| if (prerequisite_node->is_instantiatable) ------------------ | Branch (1593:7): [True: 3, False: 0] ------------------ 1594| 3| { 1595| 3| guint i; 1596| | 1597| | /* can have at most one publicly installable instantiatable prerequisite */ 1598| 3| for (i = 0; i < IFACE_NODE_N_PREREQUISITES (iface); i++) ------------------ | | 261| 3|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ | Branch (1598:19): [True: 0, False: 3] ------------------ 1599| 0| { 1600| 0| TypeNode *prnode = lookup_type_node_I (IFACE_NODE_PREREQUISITES (iface)[i]); ------------------ | | 262| 0|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 1601| | 1602| 0| if (prnode->is_instantiatable) ------------------ | Branch (1602:8): [True: 0, False: 0] ------------------ 1603| 0| { 1604| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 1605| 0| g_warning ("adding prerequisite '%s' to interface '%s' conflicts with existing prerequisite '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1606| 0| type_descriptive_name_I (prerequisite_type), 1607| 0| type_descriptive_name_I (interface_type), 1608| 0| type_descriptive_name_I (NODE_TYPE (prnode))); 1609| 0| return; 1610| 0| } 1611| 0| } 1612| | 1613| 7| for (i = 0; i < prerequisite_node->n_supers + 1u; i++) ------------------ | Branch (1613:19): [True: 4, False: 3] ------------------ 1614| 4| type_iface_add_prerequisite_W (iface, lookup_type_node_I (prerequisite_node->supers[i])); 1615| 3| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 3|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 1616| 3| } 1617| 0| else if (NODE_IS_IFACE (prerequisite_node)) ------------------ | | 258| 0|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 0|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 0|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 0, False: 0] | | ------------------ ------------------ 1618| 0| { 1619| 0| GType *prerequisites; 1620| 0| guint i; 1621| | 1622| 0| prerequisites = IFACE_NODE_PREREQUISITES (prerequisite_node); ------------------ | | 262| 0|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 1623| 0| for (i = 0; i < IFACE_NODE_N_PREREQUISITES (prerequisite_node); i++) ------------------ | | 261| 0|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ | Branch (1623:19): [True: 0, False: 0] ------------------ 1624| 0| type_iface_add_prerequisite_W (iface, lookup_type_node_I (prerequisites[i])); 1625| 0| type_iface_add_prerequisite_W (iface, prerequisite_node); 1626| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 1627| 0| } 1628| 0| else 1629| 0| { 1630| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 1631| 0| g_warning ("prerequisite '%s' for interface '%s' is neither instantiatable nor interface", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1632| 0| type_descriptive_name_I (prerequisite_type), 1633| 0| type_descriptive_name_I (interface_type)); 1634| 0| } 1635| 3|} g_type_create_instance: 1843| 7.70k|{ 1844| 7.70k| TypeNode *node; 1845| 7.70k| GTypeInstance *instance; 1846| 7.70k| GTypeClass *class; 1847| 7.70k| gchar *allocated; 1848| 7.70k| gint private_size; 1849| 7.70k| gint ivar_size; 1850| 7.70k| guint i; 1851| | 1852| 7.70k| node = lookup_type_node_I (type); 1853| 7.70k| if (!node || !node->is_instantiatable) ------------------ | Branch (1853:7): [True: 0, False: 7.70k] | Branch (1853:16): [True: 0, False: 7.70k] ------------------ 1854| 0| { 1855| 0| g_error ("cannot create new instance of invalid (non-instantiatable) type '%s'", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1856| 0| type_descriptive_name_I (type)); 1857| 0| } 1858| | /* G_TYPE_IS_ABSTRACT() is an external call: _U */ 1859| 7.70k| if (!node->mutatable_check_cache && G_TYPE_IS_ABSTRACT (type)) ------------------ | | 343| 0|#define G_TYPE_IS_ABSTRACT(type) (g_type_test_flags ((type), G_TYPE_FLAG_ABSTRACT)) | | ------------------ | | | Branch (343:49): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1859:7): [True: 0, False: 7.70k] ------------------ 1860| 0| { 1861| 0| g_error ("cannot create instance of abstract (non-instantiatable) type '%s'", ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1862| 0| type_descriptive_name_I (type)); 1863| 0| } 1864| | 1865| 7.70k| class = g_type_class_ref (type); 1866| | 1867| | /* We allocate the 'private' areas before the normal instance data, in 1868| | * reverse order. This allows the private area of a particular class 1869| | * to always be at a constant relative address to the instance data. 1870| | * If we stored the private data after the instance data this would 1871| | * not be the case (since a subclass that added more instance 1872| | * variables would push the private data further along). 1873| | * 1874| | * This presents problems for valgrindability, of course, so we do a 1875| | * workaround for that case. We identify the start of the object to 1876| | * valgrind as an allocated block (so that pointers to objects show up 1877| | * as 'reachable' instead of 'possibly lost'). We then add an extra 1878| | * pointer at the end of the object, after all instance data, back to 1879| | * the start of the private area so that it is also recorded as 1880| | * reachable. We also add extra private space at the start because 1881| | * valgrind doesn't seem to like us claiming to have allocated an 1882| | * address that it saw allocated by malloc(). 1883| | */ 1884| 7.70k| private_size = node->data->instance.private_size; 1885| 7.70k| ivar_size = node->data->instance.instance_size; 1886| | 1887| 7.70k|#ifdef ENABLE_VALGRIND 1888| 7.70k| if (private_size && RUNNING_ON_VALGRIND) ------------------ | | 6215| 7.70k| (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ | | ------------------ | | | | 413| 7.70k| __extension__ \ | | | | 414| 7.70k| ({ volatile unsigned long int _zzq_args[6]; \ | | | | 415| 7.70k| volatile unsigned long int _zzq_result; \ | | | | 416| 7.70k| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | 417| 7.70k| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | 418| 7.70k| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | 419| 7.70k| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | 420| 7.70k| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | 421| 7.70k| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | 422| 7.70k| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | 423| 7.70k| /* %RDX = client_request ( %RAX ) */ \ | | | | 424| 7.70k| "xchgq %%rbx,%%rbx" \ | | | | 425| 7.70k| : "=d" (_zzq_result) \ | | | | 426| 7.70k| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | 427| 7.70k| : "cc", "memory" \ | | | | 428| 7.70k| ); \ | | | | 429| 7.70k| _zzq_result; \ | | | | 430| 7.70k| }) | | ------------------ | | | Branch (6215:5): [True: 0, False: 7.70k] | | ------------------ ------------------ | Branch (1888:7): [True: 7.70k, False: 0] ------------------ 1889| 0| { 1890| 0| private_size += ALIGN_STRUCT (1); ------------------ | | 161| 0| ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ | | ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ ------------------ 1891| | 1892| | /* Allocate one extra pointer size... */ 1893| 0| allocated = g_slice_alloc0 (private_size + ivar_size + sizeof (gpointer)); 1894| | /* ... and point it back to the start of the private data. */ 1895| 0| *(gpointer *) (allocated + private_size + ivar_size) = allocated + ALIGN_STRUCT (1); ------------------ | | 161| 0| ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ | | ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ ------------------ 1896| | 1897| | /* Tell valgrind that it should treat the object itself as such */ 1898| 0| VALGRIND_MALLOCLIKE_BLOCK (allocated + private_size, ivar_size + sizeof (gpointer), 0, TRUE); ------------------ | | 6479| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6480| 0| addr, sizeB, rzB, is_zeroed, 0) ------------------ 1899| 0| VALGRIND_MALLOCLIKE_BLOCK (allocated + ALIGN_STRUCT (1), private_size - ALIGN_STRUCT (1), 0, TRUE); ------------------ | | 6479| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6480| 0| addr, sizeB, rzB, is_zeroed, 0) ------------------ 1900| 0| } 1901| 7.70k| else 1902| 7.70k|#endif 1903| 7.70k| allocated = g_slice_alloc0 (private_size + ivar_size); 1904| | 1905| 7.70k| instance = (GTypeInstance *) (allocated + private_size); 1906| | 1907| 23.1k| for (i = node->n_supers; i > 0; i--) ------------------ | Branch (1907:28): [True: 15.4k, False: 7.70k] ------------------ 1908| 15.4k| { 1909| 15.4k| TypeNode *pnode; 1910| | 1911| 15.4k| pnode = lookup_type_node_I (node->supers[i]); 1912| 15.4k| if (pnode->data->instance.instance_init) ------------------ | Branch (1912:11): [True: 15.4k, False: 0] ------------------ 1913| 15.4k| { 1914| 15.4k| instance->g_class = pnode->data->instance.class; 1915| 15.4k| pnode->data->instance.instance_init (instance, class); 1916| 15.4k| } 1917| 15.4k| } 1918| | 1919| 7.70k| instance->g_class = class; 1920| 7.70k| if (node->data->instance.instance_init) ------------------ | Branch (1920:7): [True: 7.70k, False: 0] ------------------ 1921| 7.70k| node->data->instance.instance_init (instance, class); 1922| | 1923| 7.70k|#ifdef G_ENABLE_DEBUG 1924| 7.70k| IF_DEBUG (INSTANCE_COUNT) ------------------ | | 42| 7.70k|#define IF_DEBUG(debug_type) if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type) | | ------------------ | | | Branch (42:34): [True: 0, False: 7.70k] | | ------------------ ------------------ 1925| 0| { 1926| 0| g_atomic_int_inc ((int *) &node->instance_count); ------------------ | | 148| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 149| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 150| 0| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (150:13): [Folded, False: 0] | | ------------------ | | 151| 0| (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ | | 152| 0| })) ------------------ 1927| 0| } 1928| 7.70k|#endif 1929| | 1930| 7.70k| TRACE(GOBJECT_OBJECT_NEW(instance, type)); 1931| | 1932| 7.70k| return instance; 1933| 7.70k|} g_type_free_instance: 1947| 7.70k|{ 1948| 7.70k| TypeNode *node; 1949| 7.70k| GTypeClass *class; 1950| 7.70k| gchar *allocated; 1951| 7.70k| gint private_size; 1952| 7.70k| gint ivar_size; 1953| | 1954| 7.70k| g_return_if_fail (instance != NULL && instance->g_class != NULL); ------------------ | | 630| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 631| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 23.1k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 632| 7.70k| { } \ | | 633| 7.70k| else \ | | 634| 7.70k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 1955| | 1956| 7.70k| class = instance->g_class; 1957| 7.70k| node = lookup_type_node_I (class->g_type); 1958| 7.70k| if (!node || !node->is_instantiatable || !node->data || node->data->class.class != (gpointer) class) ------------------ | Branch (1958:7): [True: 0, False: 7.70k] | Branch (1958:16): [True: 0, False: 7.70k] | Branch (1958:44): [True: 0, False: 7.70k] | Branch (1958:59): [True: 0, False: 7.70k] ------------------ 1959| 0| { 1960| 0| g_warning ("cannot free instance of invalid (non-instantiatable) type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1961| 0| type_descriptive_name_I (class->g_type)); 1962| 0| return; 1963| 0| } 1964| | /* G_TYPE_IS_ABSTRACT() is an external call: _U */ 1965| 7.70k| if (!node->mutatable_check_cache && G_TYPE_IS_ABSTRACT (NODE_TYPE (node))) ------------------ | | 343| 0|#define G_TYPE_IS_ABSTRACT(type) (g_type_test_flags ((type), G_TYPE_FLAG_ABSTRACT)) | | ------------------ | | | Branch (343:49): [True: 0, False: 0] | | ------------------ ------------------ | Branch (1965:7): [True: 0, False: 7.70k] ------------------ 1966| 0| { 1967| 0| g_warning ("cannot free instance of abstract (non-instantiatable) type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1968| 0| NODE_NAME (node)); 1969| 0| return; 1970| 0| } 1971| | 1972| 7.70k| instance->g_class = NULL; 1973| 7.70k| private_size = node->data->instance.private_size; 1974| 7.70k| ivar_size = node->data->instance.instance_size; 1975| 7.70k| allocated = ((gchar *) instance) - private_size; 1976| | 1977| 7.70k|#ifdef G_ENABLE_DEBUG 1978| 7.70k| memset (allocated, 0xaa, ivar_size + private_size); 1979| 7.70k|#endif 1980| | 1981| 7.70k|#ifdef ENABLE_VALGRIND 1982| | /* See comment in g_type_create_instance() about what's going on here. 1983| | * We're basically unwinding what we put into motion there. 1984| | */ 1985| 7.70k| if (private_size && RUNNING_ON_VALGRIND) ------------------ | | 6215| 7.70k| (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0 /* if not */, \ | | ------------------ | | | | 413| 7.70k| __extension__ \ | | | | 414| 7.70k| ({ volatile unsigned long int _zzq_args[6]; \ | | | | 415| 7.70k| volatile unsigned long int _zzq_result; \ | | | | 416| 7.70k| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | 417| 7.70k| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | 418| 7.70k| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | 419| 7.70k| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | 420| 7.70k| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | 421| 7.70k| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | 422| 7.70k| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | 423| 7.70k| /* %RDX = client_request ( %RAX ) */ \ | | | | 424| 7.70k| "xchgq %%rbx,%%rbx" \ | | | | 425| 7.70k| : "=d" (_zzq_result) \ | | | | 426| 7.70k| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | 427| 7.70k| : "cc", "memory" \ | | | | 428| 7.70k| ); \ | | | | 429| 7.70k| _zzq_result; \ | | | | 430| 7.70k| }) | | ------------------ | | | Branch (6215:5): [True: 0, False: 7.70k] | | ------------------ ------------------ | Branch (1985:7): [True: 7.70k, False: 0] ------------------ 1986| 0| { 1987| 0| private_size += ALIGN_STRUCT (1); ------------------ | | 161| 0| ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ | | ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ ------------------ 1988| 0| allocated -= ALIGN_STRUCT (1); ------------------ | | 161| 0| ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ | | ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ ------------------ 1989| | 1990| | /* Clear out the extra pointer... */ 1991| 0| *(gpointer *) (allocated + private_size + ivar_size) = NULL; 1992| | /* ... and ensure we include it in the size we free. */ 1993| 0| g_slice_free1 (private_size + ivar_size + sizeof (gpointer), allocated); 1994| | 1995| 0| VALGRIND_FREELIKE_BLOCK (allocated + ALIGN_STRUCT (1), 0); ------------------ | | 6493| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__FREELIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6494| 0| addr, rzB, 0, 0, 0) ------------------ 1996| 0| VALGRIND_FREELIKE_BLOCK (instance, 0); ------------------ | | 6493| 0| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__FREELIKE_BLOCK, \ | | ------------------ | | | | 203| 0| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 0| __extension__ \ | | | | | | 414| 0| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 0| volatile unsigned long int _zzq_result; \ | | | | | | 416| 0| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 0| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 0| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | 419| 0| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 0| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 0| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 0| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 0| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 0| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 0| : "=d" (_zzq_result) \ | | | | | | 426| 0| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 0| : "cc", "memory" \ | | | | | | 428| 0| ); \ | | | | | | 429| 0| _zzq_result; \ | | | | | | 430| 0| }) | | | | ------------------ | | | | 204| 0| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 0| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 6494| 0| addr, rzB, 0, 0, 0) ------------------ 1997| 0| } 1998| 7.70k| else 1999| 7.70k|#endif 2000| 7.70k| g_slice_free1 (private_size + ivar_size, allocated); 2001| | 2002| 7.70k|#ifdef G_ENABLE_DEBUG 2003| 7.70k| IF_DEBUG (INSTANCE_COUNT) ------------------ | | 42| 7.70k|#define IF_DEBUG(debug_type) if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type) | | ------------------ | | | Branch (42:34): [True: 0, False: 7.70k] | | ------------------ ------------------ 2004| 0| { 2005| 0| g_atomic_int_add ((int *) &node->instance_count, -1); ------------------ | | 167| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 168| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 169| 0| (void) (0 ? *(atomic) ^ (val) : 1); \ | | ------------------ | | | Branch (169:13): [Folded, False: 0] | | ------------------ | | 170| 0| (gint) __atomic_fetch_add ((atomic), (val), __ATOMIC_SEQ_CST); \ | | 171| 0| })) ------------------ 2006| 0| } 2007| 7.70k|#endif 2008| | 2009| 7.70k| g_type_class_unref (class); 2010| 7.70k|} g_type_add_interface_check: 2603| 1|{ 2604| 1| guint i; 2605| | 2606| 1| g_return_if_fail (check_func != NULL); ------------------ | | 630| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 631| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 632| 1| { } \ | | 633| 1| else \ | | 634| 1| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 2607| | 2608| 1| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 1|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2609| 1| i = static_n_iface_check_funcs++; 2610| 1| static_iface_check_funcs = g_renew (IFaceCheckFunc, static_iface_check_funcs, static_n_iface_check_funcs); ------------------ | | 321| 1|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 1| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 1| gsize __n = (gsize) (n_structs); \ | | | | 251| 1| gsize __s = sizeof (struct_type); \ | | | | 252| 1| gpointer __p = (gpointer) (mem); \ | | | | 253| 1| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 1] | | | | ------------------ | | | | 254| 1| __p = g_##func (__p, __n); \ | | | | 255| 1| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 0, False: 1] | | | | ------------------ | | | | 256| 1| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 0] | | | | | Branch (256:26): [True: 0, False: 0] | | | | ------------------ | | | | 257| 1| __p = g_##func (__p, __n * __s); \ | | | | 258| 1| else \ | | | | 259| 1| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 1| __p; \ | | | | 261| 1| })) | | ------------------ ------------------ 2611| 1| static_iface_check_funcs[i].check_data = check_data; 2612| 1| static_iface_check_funcs[i].check_func = check_func; 2613| 1| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 1|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2614| 1|} g_type_register_fundamental: 2680| 38|{ 2681| 38| TypeNode *node; 2682| | 2683| 38| g_assert_type_system_initialized (); ------------------ | | 140| 38| g_assert (static_quark_type_flags) | | ------------------ | | | | 231| 38|#define g_assert(expr) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 38|#define G_STMT_START do | | | | ------------------ | | | | 232| 38| if G_LIKELY (expr) ; else \ | | | | ------------------ | | | | | | 1024| 38|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | | | ------------------ | | | | | | | | 1016| 38| G_GNUC_EXTENSION ({ \ | | | | | | | | ------------------ | | | | | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | | | | | ------------------ | | | | | | | | 1017| 38| int _g_boolean_var_; \ | | | | | | | | 1018| 38| if (expr) \ | | | | | | | | ------------------ | | | | | | | | | Branch (1018:8): [True: 38, False: 0] | | | | | | | | ------------------ | | | | | | | | 1019| 38| _g_boolean_var_ = 1; \ | | | | | | | | 1020| 38| else \ | | | | | | | | 1021| 38| _g_boolean_var_ = 0; \ | | | | | | | | 1022| 38| _g_boolean_var_; \ | | | | | | | | 1023| 38|}) | | | | | | ------------------ | | | | | | | Branch (1024:25): [True: 38, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 233| 38| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | | | ------------------ | | | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | | | ------------------ | | | | 234| 0| #expr); \ | | | | 235| 38| } G_STMT_END | | | | ------------------ | | | | | | 882| 38|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 38] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2684| 38| g_return_val_if_fail (type_id > 0, 0); ------------------ | | 643| 38| G_STMT_START { \ | | ------------------ | | | | 874| 38|#define G_STMT_START do | | ------------------ | | 644| 38| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 38|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 38| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 38| int _g_boolean_var_; \ | | | | | | 1018| 38| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 38, False: 0] | | | | | | ------------------ | | | | | | 1019| 38| _g_boolean_var_ = 1; \ | | | | | | 1020| 38| else \ | | | | | | 1021| 38| _g_boolean_var_ = 0; \ | | | | | | 1022| 38| _g_boolean_var_; \ | | | | | | 1023| 38|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 38, False: 0] | | | | ------------------ | | ------------------ | | 645| 38| { } \ | | 646| 38| else \ | | 647| 38| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 38| } G_STMT_END | | ------------------ | | | | 882| 38|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 38] | | | | ------------------ | | ------------------ ------------------ 2685| 38| g_return_val_if_fail (type_name != NULL, 0); ------------------ | | 643| 38| G_STMT_START { \ | | ------------------ | | | | 874| 38|#define G_STMT_START do | | ------------------ | | 644| 38| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 38|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 38| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 38| int _g_boolean_var_; \ | | | | | | 1018| 38| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 38, False: 0] | | | | | | ------------------ | | | | | | 1019| 38| _g_boolean_var_ = 1; \ | | | | | | 1020| 38| else \ | | | | | | 1021| 38| _g_boolean_var_ = 0; \ | | | | | | 1022| 38| _g_boolean_var_; \ | | | | | | 1023| 38|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 38, False: 0] | | | | ------------------ | | ------------------ | | 645| 38| { } \ | | 646| 38| else \ | | 647| 38| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 38| } G_STMT_END | | ------------------ | | | | 882| 38|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 38] | | | | ------------------ | | ------------------ ------------------ 2686| 38| g_return_val_if_fail (info != NULL, 0); ------------------ | | 643| 38| G_STMT_START { \ | | ------------------ | | | | 874| 38|#define G_STMT_START do | | ------------------ | | 644| 38| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 38|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 38| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 38| int _g_boolean_var_; \ | | | | | | 1018| 38| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 38, False: 0] | | | | | | ------------------ | | | | | | 1019| 38| _g_boolean_var_ = 1; \ | | | | | | 1020| 38| else \ | | | | | | 1021| 38| _g_boolean_var_ = 0; \ | | | | | | 1022| 38| _g_boolean_var_; \ | | | | | | 1023| 38|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 38, False: 0] | | | | ------------------ | | ------------------ | | 645| 38| { } \ | | 646| 38| else \ | | 647| 38| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 38| } G_STMT_END | | ------------------ | | | | 882| 38|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 38] | | | | ------------------ | | ------------------ ------------------ 2687| 38| g_return_val_if_fail (finfo != NULL, 0); ------------------ | | 643| 38| G_STMT_START { \ | | ------------------ | | | | 874| 38|#define G_STMT_START do | | ------------------ | | 644| 38| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 38|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 38| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 38|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 38| int _g_boolean_var_; \ | | | | | | 1018| 38| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 38, False: 0] | | | | | | ------------------ | | | | | | 1019| 38| _g_boolean_var_ = 1; \ | | | | | | 1020| 38| else \ | | | | | | 1021| 38| _g_boolean_var_ = 0; \ | | | | | | 1022| 38| _g_boolean_var_; \ | | | | | | 1023| 38|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 38, False: 0] | | | | ------------------ | | ------------------ | | 645| 38| { } \ | | 646| 38| else \ | | 647| 38| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 38| } G_STMT_END | | ------------------ | | | | 882| 38|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 38] | | | | ------------------ | | ------------------ ------------------ 2688| | 2689| 38| if (!check_type_name_I (type_name)) ------------------ | Branch (2689:7): [True: 0, False: 38] ------------------ 2690| 0| return 0; 2691| 38| if ((type_id & TYPE_ID_MASK) || ------------------ | | 267| 38|#define TYPE_ID_MASK ((GType) ((1 << G_TYPE_FUNDAMENTAL_SHIFT) - 1)) | | ------------------ | | | | 210| 38|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | ------------------ ------------------ | Branch (2691:7): [True: 0, False: 38] ------------------ 2692| 38| type_id > G_TYPE_FUNDAMENTAL_MAX) ------------------ | | 45| 38|#define G_TYPE_FUNDAMENTAL_MAX (255 << G_TYPE_FUNDAMENTAL_SHIFT) | | ------------------ | | | | 210| 38|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | ------------------ ------------------ | Branch (2692:7): [True: 0, False: 38] ------------------ 2693| 0| { 2694| 0| g_warning ("attempt to register fundamental type '%s' with invalid type id (%" G_GSIZE_FORMAT ")", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 2695| 0| type_name, 2696| 0| type_id); 2697| 0| return 0; 2698| 0| } 2699| 38| if ((finfo->type_flags & G_TYPE_FLAG_INSTANTIATABLE) && ------------------ | Branch (2699:7): [True: 4, False: 34] ------------------ 2700| 4| !(finfo->type_flags & G_TYPE_FLAG_CLASSED)) ------------------ | Branch (2700:7): [True: 0, False: 4] ------------------ 2701| 0| { 2702| 0| g_warning ("cannot register instantiatable fundamental type '%s' as non-classed", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 2703| 0| type_name); 2704| 0| return 0; 2705| 0| } 2706| 38| if (lookup_type_node_I (type_id)) ------------------ | Branch (2706:7): [True: 0, False: 38] ------------------ 2707| 0| { 2708| 0| g_warning ("cannot register existing fundamental type '%s' (as '%s')", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 2709| 0| type_descriptive_name_I (type_id), 2710| 0| type_name); 2711| 0| return 0; 2712| 0| } 2713| | 2714| 38| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 38|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2715| 38| node = type_node_fundamental_new_W (type_id, type_name, finfo->type_flags); 2716| 38| type_add_flags_W (node, flags); 2717| | 2718| 38| if (check_type_info_I (NULL, NODE_FUNDAMENTAL_TYPE (node), type_name, info)) ------------------ | | 254| 38|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ | Branch (2718:7): [True: 38, False: 0] ------------------ 2719| 38| type_data_make_W (node, info, 2720| 38| check_value_table_I (type_name, info->value_table) ? info->value_table : NULL); ------------------ | Branch (2720:9): [True: 36, False: 2] ------------------ 2721| 38| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 38|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2722| | 2723| 38| return NODE_TYPE (node); ------------------ | | 252| 38|#define NODE_TYPE(node) (node->supers[0]) ------------------ 2724| 38|} g_type_register_static_simple: 2753| 7|{ 2754| 7| GTypeInfo info; 2755| | 2756| | /* Instances are not allowed to be larger than this. If you have a big 2757| | * fixed-length array or something, point to it instead. 2758| | */ 2759| 7| g_return_val_if_fail (class_size <= G_MAXUINT16, G_TYPE_INVALID); ------------------ | | 643| 7| G_STMT_START { \ | | ------------------ | | | | 874| 7|#define G_STMT_START do | | ------------------ | | 644| 7| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7| int _g_boolean_var_; \ | | | | | | 1018| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | ------------------ | | | | | | 1019| 7| _g_boolean_var_ = 1; \ | | | | | | 1020| 7| else \ | | | | | | 1021| 7| _g_boolean_var_ = 0; \ | | | | | | 1022| 7| _g_boolean_var_; \ | | | | | | 1023| 7|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 645| 7| { } \ | | 646| 7| else \ | | 647| 7| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7| } G_STMT_END | | ------------------ | | | | 882| 7|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7] | | | | ------------------ | | ------------------ ------------------ 2760| 7| g_return_val_if_fail (instance_size <= G_MAXUINT16, G_TYPE_INVALID); ------------------ | | 643| 7| G_STMT_START { \ | | ------------------ | | | | 874| 7|#define G_STMT_START do | | ------------------ | | 644| 7| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7| int _g_boolean_var_; \ | | | | | | 1018| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | ------------------ | | | | | | 1019| 7| _g_boolean_var_ = 1; \ | | | | | | 1020| 7| else \ | | | | | | 1021| 7| _g_boolean_var_ = 0; \ | | | | | | 1022| 7| _g_boolean_var_; \ | | | | | | 1023| 7|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 645| 7| { } \ | | 646| 7| else \ | | 647| 7| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7| } G_STMT_END | | ------------------ | | | | 882| 7|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7] | | | | ------------------ | | ------------------ ------------------ 2761| | 2762| 7| info.class_size = class_size; 2763| 7| info.base_init = NULL; 2764| 7| info.base_finalize = NULL; 2765| 7| info.class_init = class_init; 2766| 7| info.class_finalize = NULL; 2767| 7| info.class_data = NULL; 2768| 7| info.instance_size = instance_size; 2769| 7| info.n_preallocs = 0; 2770| 7| info.instance_init = instance_init; 2771| 7| info.value_table = NULL; 2772| | 2773| 7| return g_type_register_static (parent_type, type_name, &info, flags); 2774| 7|} g_type_register_static: 2796| 59|{ 2797| 59| TypeNode *pnode, *node; 2798| 59| GType type = 0; 2799| | 2800| 59| g_assert_type_system_initialized (); ------------------ | | 140| 59| g_assert (static_quark_type_flags) | | ------------------ | | | | 231| 59|#define g_assert(expr) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 59|#define G_STMT_START do | | | | ------------------ | | | | 232| 59| if G_LIKELY (expr) ; else \ | | | | ------------------ | | | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | | | ------------------ | | | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | | | ------------------ | | | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | | | ------------------ | | | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | | | 1018| 59| if (expr) \ | | | | | | | | ------------------ | | | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | | | ------------------ | | | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | | | 1020| 59| else \ | | | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | | | 1023| 59|}) | | | | | | ------------------ | | | | | | | Branch (1024:25): [True: 59, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 233| 59| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | | | ------------------ | | | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | | | ------------------ | | | | 234| 0| #expr); \ | | | | 235| 59| } G_STMT_END | | | | ------------------ | | | | | | 882| 59|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 59] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 2801| 59| g_return_val_if_fail (parent_type > 0, 0); ------------------ | | 643| 59| G_STMT_START { \ | | ------------------ | | | | 874| 59|#define G_STMT_START do | | ------------------ | | 644| 59| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | 1018| 59| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | ------------------ | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | 1020| 59| else \ | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | 1023| 59|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 59, False: 0] | | | | ------------------ | | ------------------ | | 645| 59| { } \ | | 646| 59| else \ | | 647| 59| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 59| } G_STMT_END | | ------------------ | | | | 882| 59|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 59] | | | | ------------------ | | ------------------ ------------------ 2802| 59| g_return_val_if_fail (type_name != NULL, 0); ------------------ | | 643| 59| G_STMT_START { \ | | ------------------ | | | | 874| 59|#define G_STMT_START do | | ------------------ | | 644| 59| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | 1018| 59| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | ------------------ | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | 1020| 59| else \ | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | 1023| 59|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 59, False: 0] | | | | ------------------ | | ------------------ | | 645| 59| { } \ | | 646| 59| else \ | | 647| 59| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 59| } G_STMT_END | | ------------------ | | | | 882| 59|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 59] | | | | ------------------ | | ------------------ ------------------ 2803| 59| g_return_val_if_fail (info != NULL, 0); ------------------ | | 643| 59| G_STMT_START { \ | | ------------------ | | | | 874| 59|#define G_STMT_START do | | ------------------ | | 644| 59| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | 1018| 59| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | ------------------ | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | 1020| 59| else \ | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | 1023| 59|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 59, False: 0] | | | | ------------------ | | ------------------ | | 645| 59| { } \ | | 646| 59| else \ | | 647| 59| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 59| } G_STMT_END | | ------------------ | | | | 882| 59|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 59] | | | | ------------------ | | ------------------ ------------------ 2804| | 2805| 59| if (!check_type_name_I (type_name) || ------------------ | Branch (2805:7): [True: 0, False: 59] ------------------ 2806| 59| !check_derivation_I (parent_type, type_name)) ------------------ | Branch (2806:7): [True: 0, False: 59] ------------------ 2807| 0| return 0; 2808| 59| if (info->class_finalize) ------------------ | Branch (2808:7): [True: 0, False: 59] ------------------ 2809| 0| { 2810| 0| g_warning ("class finalizer specified for static type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 2811| 0| type_name); 2812| 0| return 0; 2813| 0| } 2814| | 2815| 59| pnode = lookup_type_node_I (parent_type); 2816| 59| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 59|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2817| 59| type_data_ref_Wm (pnode); 2818| 59| if (check_type_info_I (pnode, NODE_FUNDAMENTAL_TYPE (pnode), type_name, info)) ------------------ | | 254| 59|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ | Branch (2818:7): [True: 59, False: 0] ------------------ 2819| 59| { 2820| 59| node = type_node_new_W (pnode, type_name, NULL); 2821| 59| type_add_flags_W (node, flags); 2822| 59| type = NODE_TYPE (node); ------------------ | | 252| 59|#define NODE_TYPE(node) (node->supers[0]) ------------------ 2823| 59| type_data_make_W (node, info, 2824| 59| check_value_table_I (type_name, info->value_table) ? info->value_table : NULL); ------------------ | Branch (2824:4): [True: 2, False: 57] ------------------ 2825| 59| } 2826| 59| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 59|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2827| | 2828| 59| return type; 2829| 59|} g_type_add_interface_static: 2890| 3|{ 2891| | /* G_TYPE_IS_INSTANTIATABLE() is an external call: _U */ 2892| 3| g_return_if_fail (G_TYPE_IS_INSTANTIATABLE (instance_type)); ------------------ | | 630| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 631| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 632| 3| { } \ | | 633| 3| else \ | | 634| 3| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2893| 3| g_return_if_fail (g_type_parent (interface_type) == G_TYPE_INTERFACE); ------------------ | | 630| 3| G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 631| 3| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 632| 3| { } \ | | 633| 3| else \ | | 634| 3| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2894| | 2895| | /* we only need to lock class_init_rec_mutex if instance_type already has its 2896| | * class initialized, however this function is rarely enough called to take 2897| | * the simple route and always acquire class_init_rec_mutex. 2898| | */ 2899| 3| g_rec_mutex_lock (&class_init_rec_mutex); /* required locking order: 1) class_init_rec_mutex, 2) type_rw_lock */ 2900| 3| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 3|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2901| 3| if (check_add_interface_L (instance_type, interface_type)) ------------------ | Branch (2901:7): [True: 3, False: 0] ------------------ 2902| 3| { 2903| 3| TypeNode *node = lookup_type_node_I (instance_type); 2904| 3| TypeNode *iface = lookup_type_node_I (interface_type); 2905| 3| if (check_interface_info_I (iface, NODE_TYPE (node), info)) ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ | Branch (2905:11): [True: 3, False: 0] ------------------ 2906| 3| type_add_interface_Wm (node, iface, info, NULL); 2907| 3| } 2908| 3| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 3|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2909| 3| g_rec_mutex_unlock (&class_init_rec_mutex); 2910| 3|} g_type_class_ref: 2963| 7.71k|{ 2964| 7.71k| TypeNode *node; 2965| 7.71k| GType ptype; 2966| 7.71k| gboolean holds_ref; 2967| 7.71k| GTypeClass *pclass; 2968| | 2969| | /* optimize for common code path */ 2970| 7.71k| node = lookup_type_node_I (type); 2971| 7.71k| if (!node || !node->is_classed) ------------------ | Branch (2971:7): [True: 0, False: 7.71k] | Branch (2971:16): [True: 0, False: 7.71k] ------------------ 2972| 0| { 2973| 0| g_warning ("cannot retrieve class for invalid (unclassed) type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 2974| 0| type_descriptive_name_I (type)); 2975| 0| return NULL; 2976| 0| } 2977| | 2978| 7.71k| if (G_LIKELY (type_data_ref_U (node))) ------------------ | | 1024| 7.71k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 7.71k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.71k| int _g_boolean_var_; \ | | | | 1018| 7.71k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 7.71k, False: 0] | | | | ------------------ | | | | 1019| 7.71k| _g_boolean_var_ = 1; \ | | | | 1020| 7.71k| else \ | | | | 1021| 7.71k| _g_boolean_var_ = 0; \ | | | | 1022| 7.71k| _g_boolean_var_; \ | | | | 1023| 7.71k|}) | | ------------------ | | | Branch (1024:24): [True: 7.71k, False: 0] | | ------------------ ------------------ 2979| 7.71k| { 2980| 7.71k| if (G_LIKELY (g_atomic_int_get (&node->data->class.init_state) == INITIALIZED)) ------------------ | | 1024| 7.71k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | ------------------ | | | | 1016| 7.71k| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 7.71k| int _g_boolean_var_; \ | | | | 1018| 23.1k| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [Folded, False: 7.71k] | | | | | Branch (1018:8): [True: 7.70k, False: 10] | | | | ------------------ | | | | 1019| 7.71k| _g_boolean_var_ = 1; \ | | | | 1020| 7.71k| else \ | | | | 1021| 7.71k| _g_boolean_var_ = 0; \ | | | | 1022| 7.71k| _g_boolean_var_; \ | | | | 1023| 7.71k|}) | | ------------------ | | | Branch (1024:24): [True: 7.70k, False: 10] | | ------------------ ------------------ 2981| 7.70k| return node->data->class.class; 2982| 10| holds_ref = TRUE; ------------------ | | 818| 10|#define TRUE (!FALSE) | | ------------------ | | | | 814| 10|#define FALSE (0) | | ------------------ ------------------ 2983| 10| } 2984| 0| else 2985| 0| holds_ref = FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 2986| | 2987| | /* here, we either have node->data->class.class == NULL, or a recursive 2988| | * call to g_type_class_ref() with a partly initialized class, or 2989| | * node->data->class.init_state == INITIALIZED, because any 2990| | * concurrently running initialization was guarded by class_init_rec_mutex. 2991| | */ 2992| 10| g_rec_mutex_lock (&class_init_rec_mutex); /* required locking order: 1) class_init_rec_mutex, 2) type_rw_lock */ 2993| | 2994| | /* we need an initialized parent class for initializing derived classes */ 2995| 10| ptype = NODE_PARENT_TYPE (node); ------------------ | | 253| 10|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 2996| 10| pclass = ptype ? g_type_class_ref (ptype) : NULL; ------------------ | Branch (2996:12): [True: 8, False: 2] ------------------ 2997| | 2998| 10| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 10|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2999| | 3000| 10| if (!holds_ref) ------------------ | Branch (3000:7): [True: 0, False: 10] ------------------ 3001| 0| type_data_ref_Wm (node); 3002| | 3003| 10| if (!node->data->class.class) /* class uninitialized */ ------------------ | Branch (3003:7): [True: 7, False: 3] ------------------ 3004| 7| type_class_init_Wm (node, pclass); 3005| | 3006| 10| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 10|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 3007| | 3008| 10| if (pclass) ------------------ | Branch (3008:7): [True: 8, False: 2] ------------------ 3009| 8| g_type_class_unref (pclass); 3010| | 3011| 10| g_rec_mutex_unlock (&class_init_rec_mutex); 3012| | 3013| 10| return node->data->class.class; 3014| 7.71k|} g_type_class_unref: 3027| 7.71k|{ 3028| 7.71k| TypeNode *node; 3029| 7.71k| GTypeClass *class = g_class; 3030| | 3031| 7.71k| g_return_if_fail (g_class != NULL); ------------------ | | 630| 7.71k| G_STMT_START { \ | | ------------------ | | | | 874| 7.71k|#define G_STMT_START do | | ------------------ | | 631| 7.71k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.71k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.71k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.71k| int _g_boolean_var_; \ | | | | | | 1018| 7.71k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.71k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.71k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.71k| else \ | | | | | | 1021| 7.71k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.71k| _g_boolean_var_; \ | | | | | | 1023| 7.71k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.71k, False: 0] | | | | ------------------ | | ------------------ | | 632| 7.71k| { } \ | | 633| 7.71k| else \ | | 634| 7.71k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 7.71k| } G_STMT_END | | ------------------ | | | | 882| 7.71k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.71k] | | | | ------------------ | | ------------------ ------------------ 3032| | 3033| 7.71k| node = lookup_type_node_I (class->g_type); 3034| 7.71k| if (node && node->is_classed && NODE_REFCOUNT (node)) ------------------ | | 256| 7.71k|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 7.71k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 7.71k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 7.71k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 7.71k| gint gaig_temp; \ | | | | 99| 7.71k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 7.71k] | | | | ------------------ | | | | 100| 7.71k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 7.71k| (gint) gaig_temp; \ | | | | 102| 7.71k| })) | | ------------------ | | | Branch (256:49): [True: 7.71k, False: 0] | | ------------------ ------------------ | Branch (3034:7): [True: 7.71k, False: 0] | Branch (3034:15): [True: 7.71k, False: 0] ------------------ 3035| 7.71k| type_data_unref_U (node, FALSE); ------------------ | | 814| 7.71k|#define FALSE (0) ------------------ 3036| 0| else 3037| 0| g_warning ("cannot unreference class of invalid (unclassed) type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3038| 7.71k| type_descriptive_name_I (class->g_type)); 3039| 7.71k|} g_type_class_peek: 3082| 3.85k|{ 3083| 3.85k| TypeNode *node; 3084| 3.85k| gpointer class; 3085| | 3086| 3.85k| node = lookup_type_node_I (type); 3087| 3.85k| if (node && node->is_classed && NODE_REFCOUNT (node) && ------------------ | | 256| 7.70k|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 3.85k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 3.85k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 3.85k| gint gaig_temp; \ | | | | 99| 3.85k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 3.85k] | | | | ------------------ | | | | 100| 3.85k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 3.85k| (gint) gaig_temp; \ | | | | 102| 3.85k| })) | | ------------------ | | | Branch (256:49): [True: 3.85k, False: 0] | | ------------------ ------------------ | Branch (3087:7): [True: 3.85k, False: 0] | Branch (3087:15): [True: 3.85k, False: 0] ------------------ 3088| 3.85k| g_atomic_int_get (&node->data->class.init_state) == INITIALIZED) ------------------ | | 96| 3.85k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 3.85k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 3.85k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 3.85k| gint gaig_temp; \ | | 99| 3.85k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 3.85k] | | ------------------ | | 100| 3.85k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 3.85k| (gint) gaig_temp; \ | | 102| 3.85k| })) ------------------ | Branch (3088:7): [True: 3.85k, False: 0] ------------------ 3089| | /* ref_count _may_ be 0 */ 3090| 3.85k| class = node->data->class.class; 3091| 0| else 3092| 0| class = NULL; 3093| | 3094| 3.85k| return class; 3095| 3.85k|} g_type_class_peek_static: 3112| 7.70k|{ 3113| 7.70k| TypeNode *node; 3114| 7.70k| gpointer class; 3115| | 3116| 7.70k| node = lookup_type_node_I (type); 3117| 7.70k| if (node && node->is_classed && NODE_REFCOUNT (node) && ------------------ | | 256| 15.4k|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 7.70k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 7.70k| gint gaig_temp; \ | | | | 99| 7.70k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 7.70k] | | | | ------------------ | | | | 100| 7.70k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 7.70k| (gint) gaig_temp; \ | | | | 102| 7.70k| })) | | ------------------ | | | Branch (256:49): [True: 7.70k, False: 0] | | ------------------ ------------------ | Branch (3117:7): [True: 7.70k, False: 0] | Branch (3117:15): [True: 7.70k, False: 0] ------------------ 3118| 7.70k| /* peek only static types: */ node->plugin == NULL && ------------------ | Branch (3118:37): [True: 7.70k, False: 0] ------------------ 3119| 7.70k| g_atomic_int_get (&node->data->class.init_state) == INITIALIZED) ------------------ | | 96| 7.70k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 7.70k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.70k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 7.70k| gint gaig_temp; \ | | 99| 7.70k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 7.70k] | | ------------------ | | 100| 7.70k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 7.70k| (gint) gaig_temp; \ | | 102| 7.70k| })) ------------------ | Branch (3119:7): [True: 7.70k, False: 2] ------------------ 3120| | /* ref_count _may_ be 0 */ 3121| 7.70k| class = node->data->class.class; 3122| 2| else 3123| 2| class = NULL; 3124| | 3125| 7.70k| return class; 3126| 7.70k|} g_type_class_peek_parent: 3147| 9|{ 3148| 9| TypeNode *node; 3149| 9| gpointer class = NULL; 3150| | 3151| 9| g_return_val_if_fail (g_class != NULL, NULL); ------------------ | | 643| 9| G_STMT_START { \ | | ------------------ | | | | 874| 9|#define G_STMT_START do | | ------------------ | | 644| 9| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 9|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 9| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 9|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 9| int _g_boolean_var_; \ | | | | | | 1018| 9| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 9, False: 0] | | | | | | ------------------ | | | | | | 1019| 9| _g_boolean_var_ = 1; \ | | | | | | 1020| 9| else \ | | | | | | 1021| 9| _g_boolean_var_ = 0; \ | | | | | | 1022| 9| _g_boolean_var_; \ | | | | | | 1023| 9|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 9, False: 0] | | | | ------------------ | | ------------------ | | 645| 9| { } \ | | 646| 9| else \ | | 647| 9| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 9| } G_STMT_END | | ------------------ | | | | 882| 9|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 9] | | | | ------------------ | | ------------------ ------------------ 3152| | 3153| 9| node = lookup_type_node_I (G_TYPE_FROM_CLASS (g_class)); ------------------ | | 613| 9|#define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type) ------------------ 3154| | /* We used to acquire a read lock here. That is not necessary, since 3155| | * parent->data->class.class is constant as long as the derived class 3156| | * exists. 3157| | */ 3158| 9| if (node && node->is_classed && node->data && NODE_PARENT_TYPE (node)) ------------------ | | 253| 9|#define NODE_PARENT_TYPE(node) (node->supers[1]) | | ------------------ | | | Branch (253:34): [True: 8, False: 1] | | ------------------ ------------------ | Branch (3158:7): [True: 9, False: 0] | Branch (3158:15): [True: 9, False: 0] | Branch (3158:35): [True: 9, False: 0] ------------------ 3159| 8| { 3160| 8| node = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 8|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 3161| 8| class = node->data->class.class; 3162| 8| } 3163| 1| else if (NODE_PARENT_TYPE (node)) ------------------ | | 253| 1|#define NODE_PARENT_TYPE(node) (node->supers[1]) | | ------------------ | | | Branch (253:34): [True: 0, False: 1] | | ------------------ ------------------ 3164| 0| g_warning (G_STRLOC ": invalid class pointer '%p'", g_class); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3165| | 3166| 9| return class; 3167| 9|} g_type_interface_peek: 3184| 145k|{ 3185| 145k| TypeNode *node; 3186| 145k| TypeNode *iface; 3187| 145k| gpointer vtable = NULL; 3188| 145k| GTypeClass *class = instance_class; 3189| | 3190| 145k| g_return_val_if_fail (instance_class != NULL, NULL); ------------------ | | 643| 145k| G_STMT_START { \ | | ------------------ | | | | 874| 145k|#define G_STMT_START do | | ------------------ | | 644| 145k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 145k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 145k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 145k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 145k| int _g_boolean_var_; \ | | | | | | 1018| 145k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 145k, False: 0] | | | | | | ------------------ | | | | | | 1019| 145k| _g_boolean_var_ = 1; \ | | | | | | 1020| 145k| else \ | | | | | | 1021| 145k| _g_boolean_var_ = 0; \ | | | | | | 1022| 145k| _g_boolean_var_; \ | | | | | | 1023| 145k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 145k, False: 0] | | | | ------------------ | | ------------------ | | 645| 145k| { } \ | | 646| 145k| else \ | | 647| 145k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 145k| } G_STMT_END | | ------------------ | | | | 882| 145k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 145k] | | | | ------------------ | | ------------------ ------------------ 3191| | 3192| 145k| node = lookup_type_node_I (class->g_type); 3193| 145k| iface = lookup_type_node_I (iface_type); 3194| 145k| if (node && node->is_instantiatable && iface) ------------------ | Branch (3194:7): [True: 145k, False: 0] | Branch (3194:15): [True: 145k, False: 0] | Branch (3194:42): [True: 145k, False: 0] ------------------ 3195| 145k| type_lookup_iface_vtable_I (node, iface, &vtable); 3196| 0| else 3197| 0| g_warning (G_STRLOC ": invalid class pointer '%p'", class); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3198| | 3199| 145k| return vtable; 3200| 145k|} g_type_name: 3367| 46|{ 3368| 46| TypeNode *node; 3369| | 3370| 46| g_assert_type_system_initialized (); ------------------ | | 140| 46| g_assert (static_quark_type_flags) | | ------------------ | | | | 231| 46|#define g_assert(expr) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 46|#define G_STMT_START do | | | | ------------------ | | | | 232| 46| if G_LIKELY (expr) ; else \ | | | | ------------------ | | | | | | 1024| 46|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | | | ------------------ | | | | | | | | 1016| 46| G_GNUC_EXTENSION ({ \ | | | | | | | | ------------------ | | | | | | | | | | 54| 46|#define G_GNUC_EXTENSION __extension__ | | | | | | | | ------------------ | | | | | | | | 1017| 46| int _g_boolean_var_; \ | | | | | | | | 1018| 46| if (expr) \ | | | | | | | | ------------------ | | | | | | | | | Branch (1018:8): [True: 46, False: 0] | | | | | | | | ------------------ | | | | | | | | 1019| 46| _g_boolean_var_ = 1; \ | | | | | | | | 1020| 46| else \ | | | | | | | | 1021| 46| _g_boolean_var_ = 0; \ | | | | | | | | 1022| 46| _g_boolean_var_; \ | | | | | | | | 1023| 46|}) | | | | | | ------------------ | | | | | | | Branch (1024:25): [True: 46, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 233| 46| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | | | ------------------ | | | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | | | ------------------ | | | | 234| 0| #expr); \ | | | | 235| 46| } G_STMT_END | | | | ------------------ | | | | | | 882| 46|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 46] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3371| | 3372| 46| node = lookup_type_node_I (type); 3373| | 3374| 46| return node ? NODE_NAME (node) : NULL; ------------------ | | 255| 46|#define NODE_NAME(node) (g_quark_to_string (node->qname)) ------------------ | Branch (3374:10): [True: 46, False: 0] ------------------ 3375| 46|} g_type_from_name: 3408| 147|{ 3409| 147| GType type = 0; 3410| | 3411| 147| g_return_val_if_fail (name != NULL, 0); ------------------ | | 643| 147| G_STMT_START { \ | | ------------------ | | | | 874| 147|#define G_STMT_START do | | ------------------ | | 644| 147| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 147|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 147| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 147|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 147| int _g_boolean_var_; \ | | | | | | 1018| 147| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 147, False: 0] | | | | | | ------------------ | | | | | | 1019| 147| _g_boolean_var_ = 1; \ | | | | | | 1020| 147| else \ | | | | | | 1021| 147| _g_boolean_var_ = 0; \ | | | | | | 1022| 147| _g_boolean_var_; \ | | | | | | 1023| 147|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 147, False: 0] | | | | ------------------ | | ------------------ | | 645| 147| { } \ | | 646| 147| else \ | | 647| 147| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 147| } G_STMT_END | | ------------------ | | | | 882| 147|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 147] | | | | ------------------ | | ------------------ ------------------ 3412| | 3413| 147| G_READ_LOCK (&type_rw_lock); ------------------ | | 126| 147|#define G_READ_LOCK(rw_lock) g_rw_lock_reader_lock (rw_lock) ------------------ 3414| 147| type = (GType) g_hash_table_lookup (static_type_nodes_ht, name); 3415| 147| G_READ_UNLOCK (&type_rw_lock); ------------------ | | 127| 147|#define G_READ_UNLOCK(rw_lock) g_rw_lock_reader_unlock (rw_lock) ------------------ 3416| | 3417| 147| return type; 3418| 147|} g_type_parent: 3431| 6|{ 3432| 6| TypeNode *node; 3433| | 3434| 6| node = lookup_type_node_I (type); 3435| | 3436| 6| return node ? NODE_PARENT_TYPE (node) : 0; ------------------ | | 253| 6|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ | Branch (3436:10): [True: 6, False: 0] ------------------ 3437| 6|} g_type_depth: 3450| 3|{ 3451| 3| TypeNode *node; 3452| | 3453| 3| node = lookup_type_node_I (type); 3454| | 3455| 3| return node ? node->n_supers + 1 : 0; ------------------ | Branch (3455:10): [True: 3, False: 0] ------------------ 3456| 3|} g_type_is_a: 3571| 7.72k|{ 3572| 7.72k| TypeNode *node, *iface_node; 3573| 7.72k| gboolean is_a; 3574| | 3575| 7.72k| if (type == iface_type) ------------------ | Branch (3575:7): [True: 1, False: 7.72k] ------------------ 3576| 1| return TRUE; ------------------ | | 818| 1|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1|#define FALSE (0) | | ------------------ ------------------ 3577| | 3578| 7.72k| node = lookup_type_node_I (type); 3579| 7.72k| iface_node = lookup_type_node_I (iface_type); 3580| 7.72k| is_a = node && iface_node && type_node_conforms_to_U (node, iface_node, TRUE, TRUE); ------------------ | | 818| 7.72k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 7.72k|#define FALSE (0) | | ------------------ ------------------ is_a = node && iface_node && type_node_conforms_to_U (node, iface_node, TRUE, TRUE); ------------------ | | 818| 7.72k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 7.72k|#define FALSE (0) | | ------------------ ------------------ | Branch (3580:10): [True: 7.72k, False: 0] | Branch (3580:18): [True: 7.72k, False: 0] | Branch (3580:32): [True: 7.70k, False: 18] ------------------ 3581| | 3582| 7.72k| return is_a; 3583| 7.72k|} g_type_interfaces: 3644| 1|{ 3645| 1| TypeNode *node; 3646| | 3647| 1| node = lookup_type_node_I (type); 3648| 1| if (node && node->is_instantiatable) ------------------ | Branch (3648:7): [True: 1, False: 0] | Branch (3648:15): [True: 1, False: 0] ------------------ 3649| 1| { 3650| 1| IFaceEntries *entries; 3651| 1| GType *ifaces; 3652| 1| guint i; 3653| | 3654| 1| G_READ_LOCK (&type_rw_lock); ------------------ | | 126| 1|#define G_READ_LOCK(rw_lock) g_rw_lock_reader_lock (rw_lock) ------------------ 3655| 1| entries = CLASSED_NODE_IFACES_ENTRIES_LOCKED (node); ------------------ | | 260| 1|#define CLASSED_NODE_IFACES_ENTRIES_LOCKED(node)(G_ATOMIC_ARRAY_GET_LOCKED(CLASSED_NODE_IFACES_ENTRIES((node)), IFaceEntries)) | | ------------------ | | | | 42| 1|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) | | ------------------ ------------------ 3656| 1| if (entries) ------------------ | Branch (3656:11): [True: 0, False: 1] ------------------ 3657| 0| { 3658| 0| ifaces = g_new (GType, IFACE_ENTRIES_N_ENTRIES (entries) + 1); ------------------ | | 290| 0|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 0| gsize __n = (gsize) (n_structs); \ | | | | 237| 0| gsize __s = sizeof (struct_type); \ | | | | 238| 0| gpointer __p; \ | | | | 239| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 0] | | | | ------------------ | | | | 240| 0| __p = g_##func (__n); \ | | | | 241| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 0, False: 0] | | | | ------------------ | | | | 242| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 0] | | | | | Branch (242:26): [True: 0, False: 0] | | | | ------------------ | | | | 243| 0| __p = g_##func (__n * __s); \ | | | | 244| 0| else \ | | | | 245| 0| __p = g_##func##_n (__n, __s); \ | | | | 246| 0| __p; \ | | | | 247| 0| })) | | ------------------ ------------------ 3659| 0| for (i = 0; i < IFACE_ENTRIES_N_ENTRIES (entries); i++) ------------------ | | 294| 0|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 0|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 0|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (3659:16): [True: 0, False: 0] ------------------ 3660| 0| ifaces[i] = entries->entry[i].iface_type; 3661| 0| } 3662| 1| else 3663| 1| { 3664| 1| ifaces = g_new (GType, 1); ------------------ | | 290| 1|#define g_new(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc) | | ------------------ | | | | 235| 1| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 1| gsize __n = (gsize) (n_structs); \ | | | | 237| 1| gsize __s = sizeof (struct_type); \ | | | | 238| 1| gpointer __p; \ | | | | 239| 1| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 1] | | | | ------------------ | | | | 240| 1| __p = g_##func (__n); \ | | | | 241| 1| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 1, False: 0] | | | | ------------------ | | | | 242| 1| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 1|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 1|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 1] | | | | | Branch (242:26): [True: 1, False: 0] | | | | ------------------ | | | | 243| 1| __p = g_##func (__n * __s); \ | | | | 244| 1| else \ | | | | 245| 1| __p = g_##func##_n (__n, __s); \ | | | | 246| 1| __p; \ | | | | 247| 1| })) | | ------------------ ------------------ 3665| 1| i = 0; 3666| 1| } 3667| 1| ifaces[i] = 0; 3668| | 3669| 1| if (n_interfaces) ------------------ | Branch (3669:11): [True: 1, False: 0] ------------------ 3670| 1| *n_interfaces = i; 3671| 1| G_READ_UNLOCK (&type_rw_lock); ------------------ | | 127| 1|#define G_READ_UNLOCK(rw_lock) g_rw_lock_reader_unlock (rw_lock) ------------------ 3672| | 3673| 1| return ifaces; 3674| 1| } 3675| 0| else 3676| 0| { 3677| 0| if (n_interfaces) ------------------ | Branch (3677:11): [True: 0, False: 0] ------------------ 3678| 0| *n_interfaces = 0; 3679| | 3680| | return NULL; 3681| 0| } 3682| 1|} g_type_test_flags: 3916| 5|{ 3917| 5| TypeNode *node; 3918| 5| gboolean result = FALSE; ------------------ | | 814| 5|#define FALSE (0) ------------------ 3919| | 3920| 5| node = lookup_type_node_I (type); 3921| 5| if (node) ------------------ | Branch (3921:7): [True: 5, False: 0] ------------------ 3922| 5| { 3923| 5| guint fflags = flags & TYPE_FUNDAMENTAL_FLAG_MASK; ------------------ | | 142| 5|#define TYPE_FUNDAMENTAL_FLAG_MASK (G_TYPE_FLAG_CLASSED | \ | | 143| 5| G_TYPE_FLAG_INSTANTIATABLE | \ | | 144| 5| G_TYPE_FLAG_DERIVABLE | \ | | 145| 5| G_TYPE_FLAG_DEEP_DERIVABLE) ------------------ 3924| 5| guint tflags = flags & TYPE_FLAG_MASK; ------------------ | | 146| 5|#define TYPE_FLAG_MASK (G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT) ------------------ 3925| | 3926| 5| if (fflags) ------------------ | Branch (3926:11): [True: 5, False: 0] ------------------ 3927| 5| { 3928| 5| GTypeFundamentalInfo *finfo = type_node_fundamental_info_I (node); 3929| | 3930| 5| fflags = (finfo->type_flags & fflags) == fflags; 3931| 5| } 3932| 0| else 3933| 0| fflags = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 3934| | 3935| 5| if (tflags) ------------------ | Branch (3935:11): [True: 0, False: 5] ------------------ 3936| 0| { 3937| 0| G_READ_LOCK (&type_rw_lock); ------------------ | | 126| 0|#define G_READ_LOCK(rw_lock) g_rw_lock_reader_lock (rw_lock) ------------------ 3938| 0| tflags = (tflags & GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags))) == tflags; ------------------ | | 99| 0|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 3939| 0| G_READ_UNLOCK (&type_rw_lock); ------------------ | | 127| 0|#define G_READ_UNLOCK(rw_lock) g_rw_lock_reader_unlock (rw_lock) ------------------ 3940| 0| } 3941| 5| else 3942| 5| tflags = TRUE; ------------------ | | 818| 5|#define TRUE (!FALSE) | | ------------------ | | | | 814| 5|#define FALSE (0) | | ------------------ ------------------ 3943| | 3944| 5| result = tflags && fflags; ------------------ | Branch (3944:16): [True: 5, False: 0] | Branch (3944:26): [True: 5, False: 0] ------------------ 3945| 5| } 3946| | 3947| 5| return result; 3948| 5|} g_type_fundamental: 4052| 7.71k|{ 4053| 7.71k| TypeNode *node = lookup_type_node_I (type_id); 4054| | 4055| 7.71k| return node ? NODE_FUNDAMENTAL_TYPE (node) : 0; ------------------ | | 254| 7.71k|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ | Branch (4055:10): [True: 7.71k, False: 0] ------------------ 4056| 7.71k|} g_type_check_instance_is_a: 4061| 819k|{ 4062| 819k| TypeNode *node, *iface; 4063| 819k| gboolean check; 4064| | 4065| 819k| if (!type_instance || !type_instance->g_class) ------------------ | Branch (4065:7): [True: 0, False: 819k] | Branch (4065:25): [True: 0, False: 819k] ------------------ 4066| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 4067| | 4068| 819k| node = lookup_type_node_I (type_instance->g_class->g_type); 4069| 819k| iface = lookup_type_node_I (iface_type); 4070| 819k| check = node && node->is_instantiatable && iface && type_node_conforms_to_U (node, iface, TRUE, FALSE); ------------------ | | 818| 819k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 819k|#define FALSE (0) | | ------------------ ------------------ check = node && node->is_instantiatable && iface && type_node_conforms_to_U (node, iface, TRUE, FALSE); ------------------ | | 814| 819k|#define FALSE (0) ------------------ | Branch (4070:11): [True: 819k, False: 0] | Branch (4070:19): [True: 819k, False: 0] | Branch (4070:46): [True: 819k, False: 0] | Branch (4070:55): [True: 819k, False: 0] ------------------ 4071| | 4072| 819k| return check; 4073| 819k|} g_type_check_instance_is_fundamentally_a: 4078| 26.9k|{ 4079| 26.9k| TypeNode *node; 4080| 26.9k| if (!type_instance || !type_instance->g_class) ------------------ | Branch (4080:7): [True: 0, False: 26.9k] | Branch (4080:25): [True: 0, False: 26.9k] ------------------ 4081| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 4082| 26.9k| node = lookup_type_node_I (type_instance->g_class->g_type); 4083| 26.9k| return node && (NODE_FUNDAMENTAL_TYPE(node) == fundamental_type); ------------------ | | 254| 26.9k|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ | Branch (4083:10): [True: 26.9k, False: 0] | Branch (4083:18): [True: 26.9k, False: 0] ------------------ 4084| 26.9k|} g_type_check_class_is_a: 4089| 4|{ 4090| 4| TypeNode *node, *iface; 4091| 4| gboolean check; 4092| | 4093| 4| if (!type_class) ------------------ | Branch (4093:7): [True: 0, False: 4] ------------------ 4094| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 4095| | 4096| 4| node = lookup_type_node_I (type_class->g_type); 4097| 4| iface = lookup_type_node_I (is_a_type); 4098| 4| check = node && node->is_classed && iface && type_node_conforms_to_U (node, iface, FALSE, FALSE); ------------------ | | 814| 4|#define FALSE (0) ------------------ check = node && node->is_classed && iface && type_node_conforms_to_U (node, iface, FALSE, FALSE); ------------------ | | 814| 4|#define FALSE (0) ------------------ | Branch (4098:11): [True: 4, False: 0] | Branch (4098:19): [True: 4, False: 0] | Branch (4098:39): [True: 4, False: 0] | Branch (4098:48): [True: 4, False: 0] ------------------ 4099| | 4100| 4| return check; 4101| 4|} g_type_check_instance_cast: 4106| 455k|{ 4107| 455k| if (type_instance) ------------------ | Branch (4107:7): [True: 455k, False: 0] ------------------ 4108| 455k| { 4109| 455k| if (type_instance->g_class) ------------------ | Branch (4109:11): [True: 455k, False: 0] ------------------ 4110| 455k| { 4111| 455k| TypeNode *node, *iface; 4112| 455k| gboolean is_instantiatable, check; 4113| | 4114| 455k| node = lookup_type_node_I (type_instance->g_class->g_type); 4115| 455k| is_instantiatable = node && node->is_instantiatable; ------------------ | Branch (4115:24): [True: 455k, False: 0] | Branch (4115:32): [True: 455k, False: 0] ------------------ 4116| 455k| iface = lookup_type_node_I (iface_type); 4117| 455k| check = is_instantiatable && iface && type_node_conforms_to_U (node, iface, TRUE, FALSE); ------------------ | | 818| 455k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 455k|#define FALSE (0) | | ------------------ ------------------ check = is_instantiatable && iface && type_node_conforms_to_U (node, iface, TRUE, FALSE); ------------------ | | 814| 455k|#define FALSE (0) ------------------ | Branch (4117:12): [True: 455k, False: 0] | Branch (4117:33): [True: 455k, False: 0] | Branch (4117:42): [True: 455k, False: 0] ------------------ 4118| 455k| if (check) ------------------ | Branch (4118:8): [True: 455k, False: 0] ------------------ 4119| 455k| return type_instance; 4120| | 4121| 0| if (is_instantiatable) ------------------ | Branch (4121:8): [True: 0, False: 0] ------------------ 4122| 0| g_warning ("invalid cast from '%s' to '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4123| 0| type_descriptive_name_I (type_instance->g_class->g_type), 4124| 0| type_descriptive_name_I (iface_type)); 4125| 0| else 4126| 0| g_warning ("invalid uninstantiatable type '%s' in cast to '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4127| 0| type_descriptive_name_I (type_instance->g_class->g_type), 4128| 0| type_descriptive_name_I (iface_type)); 4129| 0| } 4130| 0| else 4131| 0| g_warning ("invalid unclassed pointer in cast to '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4132| 455k| type_descriptive_name_I (iface_type)); 4133| 455k| } 4134| | 4135| 0| return type_instance; 4136| 455k|} g_type_check_class_cast: 4141| 19.2k|{ 4142| 19.2k| if (type_class) ------------------ | Branch (4142:7): [True: 19.2k, False: 0] ------------------ 4143| 19.2k| { 4144| 19.2k| TypeNode *node, *iface; 4145| 19.2k| gboolean is_classed, check; 4146| | 4147| 19.2k| node = lookup_type_node_I (type_class->g_type); 4148| 19.2k| is_classed = node && node->is_classed; ------------------ | Branch (4148:20): [True: 19.2k, False: 0] | Branch (4148:28): [True: 19.2k, False: 0] ------------------ 4149| 19.2k| iface = lookup_type_node_I (is_a_type); 4150| 19.2k| check = is_classed && iface && type_node_conforms_to_U (node, iface, FALSE, FALSE); ------------------ | | 814| 19.2k|#define FALSE (0) ------------------ check = is_classed && iface && type_node_conforms_to_U (node, iface, FALSE, FALSE); ------------------ | | 814| 19.2k|#define FALSE (0) ------------------ | Branch (4150:15): [True: 19.2k, False: 0] | Branch (4150:29): [True: 19.2k, False: 0] | Branch (4150:38): [True: 19.2k, False: 0] ------------------ 4151| 19.2k| if (check) ------------------ | Branch (4151:11): [True: 19.2k, False: 0] ------------------ 4152| 19.2k| return type_class; 4153| | 4154| 0| if (is_classed) ------------------ | Branch (4154:11): [True: 0, False: 0] ------------------ 4155| 0| g_warning ("invalid class cast from '%s' to '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4156| 0| type_descriptive_name_I (type_class->g_type), 4157| 0| type_descriptive_name_I (is_a_type)); 4158| 0| else 4159| 0| g_warning ("invalid unclassed type '%s' in class cast to '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4160| 0| type_descriptive_name_I (type_class->g_type), 4161| 0| type_descriptive_name_I (is_a_type)); 4162| 0| } 4163| 0| else 4164| 0| g_warning ("invalid class cast from (NULL) pointer to '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4165| 19.2k| type_descriptive_name_I (is_a_type)); 4166| 0| return type_class; 4167| 19.2k|} g_type_check_instance: 4180| 19.2k|{ 4181| | /* this function is just here to make the signal system 4182| | * conveniently elaborated on instance checks 4183| | */ 4184| 19.2k| if (type_instance) ------------------ | Branch (4184:7): [True: 19.2k, False: 0] ------------------ 4185| 19.2k| { 4186| 19.2k| if (type_instance->g_class) ------------------ | Branch (4186:11): [True: 19.2k, False: 0] ------------------ 4187| 19.2k| { 4188| 19.2k| TypeNode *node = lookup_type_node_I (type_instance->g_class->g_type); 4189| | 4190| 19.2k| if (node && node->is_instantiatable) ------------------ | Branch (4190:8): [True: 19.2k, False: 0] | Branch (4190:16): [True: 19.2k, False: 0] ------------------ 4191| 19.2k| return TRUE; ------------------ | | 818| 19.2k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 19.2k|#define FALSE (0) | | ------------------ ------------------ 4192| | 4193| 0| g_warning ("instance of invalid non-instantiatable type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4194| 0| type_descriptive_name_I (type_instance->g_class->g_type)); 4195| 0| } 4196| 0| else 4197| 0| g_warning ("instance with invalid (NULL) class pointer"); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4198| 19.2k| } 4199| 0| else 4200| 0| g_warning ("invalid (NULL) pointer instance"); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4201| | 4202| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 4203| 19.2k|} g_type_check_is_value_type: 4248| 1|{ 4249| 1| return type_check_is_value_type_U (type); 4250| 1|} g_type_check_value: 4254| 3.85k|{ 4255| 3.85k| return value && type_check_is_value_type_U (value->g_type); ------------------ | Branch (4255:10): [True: 3.85k, False: 0] | Branch (4255:19): [True: 3.85k, False: 0] ------------------ 4256| 3.85k|} g_type_check_value_holds: 4261| 3.85k|{ 4262| 3.85k| return value && type_check_is_value_type_U (value->g_type) && g_type_is_a (value->g_type, type); ------------------ | Branch (4262:10): [True: 3.85k, False: 0] | Branch (4262:19): [True: 3.85k, False: 0] | Branch (4262:65): [True: 3.85k, False: 0] ------------------ 4263| 3.85k|} g_type_value_table_peek: 4280| 11.5k|{ 4281| 11.5k| GTypeValueTable *vtable = NULL; 4282| 11.5k| TypeNode *node = lookup_type_node_I (type); 4283| 11.5k| gboolean has_refed_data, has_table; 4284| | 4285| 11.5k| if (node && NODE_REFCOUNT (node) && node->mutatable_check_cache) ------------------ | | 256| 23.1k|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 11.5k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 11.5k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 11.5k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 11.5k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 11.5k| gint gaig_temp; \ | | | | 99| 11.5k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 11.5k] | | | | ------------------ | | | | 100| 11.5k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 11.5k| (gint) gaig_temp; \ | | | | 102| 11.5k| })) | | ------------------ | | | Branch (256:49): [True: 11.5k, False: 0] | | ------------------ ------------------ | Branch (4285:7): [True: 11.5k, False: 0] | Branch (4285:39): [True: 11.5k, False: 0] ------------------ 4286| 11.5k| return node->data->common.value_table; 4287| | 4288| 0| G_READ_LOCK (&type_rw_lock); ------------------ | | 126| 0|#define G_READ_LOCK(rw_lock) g_rw_lock_reader_lock (rw_lock) ------------------ 4289| | 4290| 0| restart_table_peek: 4291| 0| has_refed_data = node && node->data && NODE_REFCOUNT (node) > 0; ------------------ | | 256| 0|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 0| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 0| gint gaig_temp; \ | | | | 99| 0| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 0] | | | | ------------------ | | | | 100| 0| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 0| (gint) gaig_temp; \ | | | | 102| 0| })) | | ------------------ ------------------ | Branch (4291:20): [True: 0, False: 0] | Branch (4291:28): [True: 0, False: 0] | Branch (4291:42): [True: 0, False: 0] ------------------ 4292| 0| has_table = has_refed_data && node->data->common.value_table->value_init; ------------------ | Branch (4292:15): [True: 0, False: 0] | Branch (4292:33): [True: 0, False: 0] ------------------ 4293| 0| if (has_refed_data) ------------------ | Branch (4293:7): [True: 0, False: 0] ------------------ 4294| 0| { 4295| 0| if (has_table) ------------------ | Branch (4295:11): [True: 0, False: 0] ------------------ 4296| 0| vtable = node->data->common.value_table; 4297| 0| else if (NODE_IS_IFACE (node)) ------------------ | | 258| 0|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 0|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 0|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 0, False: 0] | | ------------------ ------------------ 4298| 0| { 4299| 0| guint i; 4300| | 4301| 0| for (i = 0; i < IFACE_NODE_N_PREREQUISITES (node); i++) ------------------ | | 261| 0|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ | Branch (4301:16): [True: 0, False: 0] ------------------ 4302| 0| { 4303| 0| GType prtype = IFACE_NODE_PREREQUISITES (node)[i]; ------------------ | | 262| 0|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 4304| 0| TypeNode *prnode = lookup_type_node_I (prtype); 4305| | 4306| 0| if (prnode->is_instantiatable) ------------------ | Branch (4306:12): [True: 0, False: 0] ------------------ 4307| 0| { 4308| 0| type = prtype; 4309| 0| node = lookup_type_node_I (type); 4310| 0| goto restart_table_peek; 4311| 0| } 4312| 0| } 4313| 0| } 4314| 0| } 4315| | 4316| 0| G_READ_UNLOCK (&type_rw_lock); ------------------ | | 127| 0|#define G_READ_UNLOCK(rw_lock) g_rw_lock_reader_unlock (rw_lock) ------------------ 4317| | 4318| 0| if (vtable) ------------------ | Branch (4318:7): [True: 0, False: 0] ------------------ 4319| 0| return vtable; 4320| | 4321| 0| if (!node) ------------------ | Branch (4321:7): [True: 0, False: 0] ------------------ 4322| 0| g_warning (G_STRLOC ": type id '%" G_GSIZE_FORMAT "' is invalid", type); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4323| 0| if (!has_refed_data) ------------------ | Branch (4323:7): [True: 0, False: 0] ------------------ 4324| 0| g_warning ("can't peek value table for type '%s' which is not currently referenced", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4325| 0| type_descriptive_name_I (type)); 4326| | 4327| | return NULL; 4328| 0|} _g_type_boxed_init: 4370| 2|{ 4371| 2| TypeNode *node = lookup_type_node_I (type); 4372| | 4373| 2| node->data->boxed.copy_func = copy_func; 4374| 2| node->data->boxed.free_func = free_func; 4375| 2|} gtype.c:gobject_init_ctor: 4546| 2|{ 4547| 2| gobject_init (); 4548| 2|} g_type_add_instance_private: 4667| 6|{ 4668| 6| TypeNode *node = lookup_type_node_I (class_gtype); 4669| | 4670| 6| g_return_val_if_fail (private_size > 0, 0); ------------------ | | 643| 6| G_STMT_START { \ | | ------------------ | | | | 874| 6|#define G_STMT_START do | | ------------------ | | 644| 6| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 6|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 6| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 6|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 6| int _g_boolean_var_; \ | | | | | | 1018| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 6, False: 0] | | | | | | ------------------ | | | | | | 1019| 6| _g_boolean_var_ = 1; \ | | | | | | 1020| 6| else \ | | | | | | 1021| 6| _g_boolean_var_ = 0; \ | | | | | | 1022| 6| _g_boolean_var_; \ | | | | | | 1023| 6|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 6, False: 0] | | | | ------------------ | | ------------------ | | 645| 6| { } \ | | 646| 6| else \ | | 647| 6| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 6| } G_STMT_END | | ------------------ | | | | 882| 6|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 4671| 6| g_return_val_if_fail (private_size <= 0xffff, 0); ------------------ | | 643| 6| G_STMT_START { \ | | ------------------ | | | | 874| 6|#define G_STMT_START do | | ------------------ | | 644| 6| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 6|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 6| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 6|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 6| int _g_boolean_var_; \ | | | | | | 1018| 6| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 6, False: 0] | | | | | | ------------------ | | | | | | 1019| 6| _g_boolean_var_ = 1; \ | | | | | | 1020| 6| else \ | | | | | | 1021| 6| _g_boolean_var_ = 0; \ | | | | | | 1022| 6| _g_boolean_var_; \ | | | | | | 1023| 6|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 6, False: 0] | | | | ------------------ | | ------------------ | | 645| 6| { } \ | | 646| 6| else \ | | 647| 6| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 6| } G_STMT_END | | ------------------ | | | | 882| 6|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 4672| | 4673| 6| if (!node || !node->is_classed || !node->is_instantiatable || !node->data) ------------------ | Branch (4673:7): [True: 0, False: 6] | Branch (4673:16): [True: 0, False: 6] | Branch (4673:37): [True: 0, False: 6] | Branch (4673:65): [True: 0, False: 6] ------------------ 4674| 0| { 4675| 0| g_warning ("cannot add private field to invalid (non-instantiatable) type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4676| 0| type_descriptive_name_I (class_gtype)); 4677| 0| return 0; 4678| 0| } 4679| | 4680| 6| if (node->plugin != NULL) ------------------ | Branch (4680:7): [True: 0, False: 6] ------------------ 4681| 0| { 4682| 0| g_warning ("cannot use g_type_add_instance_private() with dynamic type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4683| 0| type_descriptive_name_I (class_gtype)); 4684| 0| return 0; 4685| 0| } 4686| | 4687| | /* in the future, we want to register the private data size of a type 4688| | * directly from the get_type() implementation so that we can take full 4689| | * advantage of the type definition macros that we already have. 4690| | * 4691| | * unfortunately, this does not behave correctly if a class in the middle 4692| | * of the type hierarchy uses the "old style" of private data registration 4693| | * from the class_init() implementation, as the private data offset is not 4694| | * going to be known until the full class hierarchy is initialized. 4695| | * 4696| | * in order to transition our code to the Glorious New Future™, we proceed 4697| | * with a two-step implementation: first, we provide this new function to 4698| | * register the private data size in the get_type() implementation and we 4699| | * hide it behind a macro. the function will return the private size, instead 4700| | * of the offset, which will be stored inside a static variable defined by 4701| | * the G_DEFINE_TYPE_EXTENDED macro. the G_DEFINE_TYPE_EXTENDED macro will 4702| | * check the variable and call g_type_class_add_instance_private(), which 4703| | * will use the data size and actually register the private data, then 4704| | * return the computed offset of the private data, which will be stored 4705| | * inside the static variable, so we can use it to retrieve the pointer 4706| | * to the private data structure. 4707| | * 4708| | * once all our code has been migrated to the new idiomatic form of private 4709| | * data registration, we will change the g_type_add_instance_private() 4710| | * function to actually perform the registration and return the offset 4711| | * of the private data; g_type_class_add_instance_private() already checks 4712| | * if the passed argument is negative (meaning that it's an offset in the 4713| | * GTypeInstance allocation) and becomes a no-op if that's the case. this 4714| | * should make the migration fully transparent even if we're effectively 4715| | * copying this macro into everybody's code. 4716| | */ 4717| 6| return private_size; 4718| 6|} g_type_class_adjust_private_offset: 4724| 5|{ 4725| 5| GType class_gtype = ((GTypeClass *) g_class)->g_type; 4726| 5| TypeNode *node = lookup_type_node_I (class_gtype); 4727| 5| gssize private_size; 4728| | 4729| 5| g_return_if_fail (private_size_or_offset != NULL); ------------------ | | 630| 5| G_STMT_START { \ | | ------------------ | | | | 874| 5|#define G_STMT_START do | | ------------------ | | 631| 5| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 5|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 5| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 5|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 5| int _g_boolean_var_; \ | | | | | | 1018| 5| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5, False: 0] | | | | | | ------------------ | | | | | | 1019| 5| _g_boolean_var_ = 1; \ | | | | | | 1020| 5| else \ | | | | | | 1021| 5| _g_boolean_var_ = 0; \ | | | | | | 1022| 5| _g_boolean_var_; \ | | | | | | 1023| 5|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 5, False: 0] | | | | ------------------ | | ------------------ | | 632| 5| { } \ | | 633| 5| else \ | | 634| 5| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 5| } G_STMT_END | | ------------------ | | | | 882| 5|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 5] | | | | ------------------ | | ------------------ ------------------ 4730| | 4731| | /* if we have been passed the offset instead of the private data size, 4732| | * then we consider this as a no-op, and just return the value. see the 4733| | * comment in g_type_add_instance_private() for the full explanation. 4734| | */ 4735| 5| if (*private_size_or_offset > 0) ------------------ | Branch (4735:7): [True: 5, False: 0] ------------------ 4736| 5| g_return_if_fail (*private_size_or_offset <= 0xffff); ------------------ | | 630| 5| G_STMT_START { \ | | ------------------ | | | | 874| 5|#define G_STMT_START do | | ------------------ | | 631| 5| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 5|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 5| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 5|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 5| int _g_boolean_var_; \ | | | | | | 1018| 5| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5, False: 0] | | | | | | ------------------ | | | | | | 1019| 5| _g_boolean_var_ = 1; \ | | | | | | 1020| 5| else \ | | | | | | 1021| 5| _g_boolean_var_ = 0; \ | | | | | | 1022| 5| _g_boolean_var_; \ | | | | | | 1023| 5|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 5, False: 0] | | | | ------------------ | | ------------------ | | 632| 5| { } \ | | 633| 5| else \ | | 634| 5| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 5| } G_STMT_END | | ------------------ | | | | 882| 5|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 5] | | | | ------------------ | | ------------------ ------------------ 4737| 0| else 4738| 0| return; 4739| | 4740| 5| if (!node || !node->is_classed || !node->is_instantiatable || !node->data) ------------------ | Branch (4740:7): [True: 0, False: 5] | Branch (4740:16): [True: 0, False: 5] | Branch (4740:37): [True: 0, False: 5] | Branch (4740:65): [True: 0, False: 5] ------------------ 4741| 0| { 4742| 0| g_warning ("cannot add private field to invalid (non-instantiatable) type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4743| 0| type_descriptive_name_I (class_gtype)); 4744| 0| *private_size_or_offset = 0; 4745| 0| return; 4746| 0| } 4747| | 4748| 5| if (NODE_PARENT_TYPE (node)) ------------------ | | 253| 5|#define NODE_PARENT_TYPE(node) (node->supers[1]) | | ------------------ | | | Branch (253:34): [True: 4, False: 1] | | ------------------ ------------------ 4749| 4| { 4750| 4| TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 4|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 4751| 4| if (node->data->instance.private_size != pnode->data->instance.private_size) ------------------ | Branch (4751:11): [True: 0, False: 4] ------------------ 4752| 0| { 4753| 0| g_warning ("g_type_add_instance_private() called multiple times for the same type"); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 4754| 0| *private_size_or_offset = 0; 4755| 0| return; 4756| 0| } 4757| 4| } 4758| | 4759| 5| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 5|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 4760| | 4761| 5| private_size = ALIGN_STRUCT (node->data->instance.private_size + *private_size_or_offset); ------------------ | | 161| 5| ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 5|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ | | ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 5|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ ------------------ 4762| 5| g_assert (private_size <= 0xffff); ------------------ | | 231| 5|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 5|#define G_STMT_START do | | ------------------ | | 232| 5| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 5|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 5| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 5|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 5| int _g_boolean_var_; \ | | | | | | 1018| 5| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 5, False: 0] | | | | | | ------------------ | | | | | | 1019| 5| _g_boolean_var_ = 1; \ | | | | | | 1020| 5| else \ | | | | | | 1021| 5| _g_boolean_var_ = 0; \ | | | | | | 1022| 5| _g_boolean_var_; \ | | | | | | 1023| 5|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 5, False: 0] | | | | ------------------ | | ------------------ | | 233| 5| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 5| } G_STMT_END | | ------------------ | | | | 882| 5|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 5] | | | | ------------------ | | ------------------ ------------------ 4763| 5| node->data->instance.private_size = private_size; 4764| | 4765| 5| *private_size_or_offset = -(gint) node->data->instance.private_size; 4766| | 4767| 5| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 5|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 4768| 5|} g_type_ensure: 4956| 2|{ 4957| | /* In theory, @type has already been resolved and so there's nothing 4958| | * to do here. But this protects us in the case where the function 4959| | * gets inlined (as it might in gobject_init_ctor() above). 4960| | */ 4961| 2| if (G_UNLIKELY (type == (GType)-1)) ------------------ | | 1025| 2|#define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0)) | | ------------------ | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 1017| 2| int _g_boolean_var_; \ | | | | 1018| 2| if (expr) \ | | | | ------------------ | | | | | Branch (1018:8): [True: 0, False: 2] | | | | ------------------ | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | 1020| 2| else \ | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | 1022| 2| _g_boolean_var_; \ | | | | 1023| 2|}) | | ------------------ | | | Branch (1025:26): [True: 0, False: 2] | | ------------------ ------------------ 4962| 2| g_error ("can't happen"); ------------------ | | 333| 0|#define g_error(...) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 334| 0| g_log (G_LOG_DOMAIN, \ | | 335| 0| G_LOG_LEVEL_ERROR, \ | | 336| 0| __VA_ARGS__); \ | | 337| 0| for (;;) ; \ | | 338| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4963| 2|} gtype.c:lookup_type_node_I: 395| 3.02M|{ 396| 3.02M| if (utype > G_TYPE_FUNDAMENTAL_MAX) ------------------ | | 45| 3.02M|#define G_TYPE_FUNDAMENTAL_MAX (255 << G_TYPE_FUNDAMENTAL_SHIFT) | | ------------------ | | | | 210| 3.02M|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | ------------------ ------------------ | Branch (396:7): [True: 2.97M, False: 50.5k] ------------------ 397| 2.97M| return (TypeNode*) (utype & ~TYPE_ID_MASK); ------------------ | | 267| 2.97M|#define TYPE_ID_MASK ((GType) ((1 << G_TYPE_FUNDAMENTAL_SHIFT) - 1)) | | ------------------ | | | | 210| 2.97M|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | ------------------ ------------------ 398| 50.5k| else 399| 50.5k| return static_fundamental_type_nodes[utype >> G_TYPE_FUNDAMENTAL_SHIFT]; ------------------ | | 210| 50.5k|#define G_TYPE_FUNDAMENTAL_SHIFT (2) ------------------ 400| 3.02M|} gtype.c:type_iface_add_prerequisite_W: 1508| 4|{ 1509| 4| GType prerequisite_type = NODE_TYPE (prerequisite_node); ------------------ | | 252| 4|#define NODE_TYPE(node) (node->supers[0]) ------------------ 1510| 4| GType *prerequisites, *dependants; 1511| 4| guint n_dependants, i; 1512| | 1513| 4| g_assert (NODE_IS_IFACE (iface) && ------------------ | | 231| 4|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 4|#define G_STMT_START do | | ------------------ | | 232| 4| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 4|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 4| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 4|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 4| int _g_boolean_var_; \ | | | | | | 1018| 24| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 4, False: 0] | | | | | | | Branch (1018:8): [True: 4, False: 0] | | | | | | | Branch (1018:8): [True: 4, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 4| _g_boolean_var_ = 1; \ | | | | | | 1020| 4| else \ | | | | | | 1021| 4| _g_boolean_var_ = 0; \ | | | | | | 1022| 4| _g_boolean_var_; \ | | | | | | 1023| 4|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 4, False: 0] | | | | ------------------ | | ------------------ | | 233| 4| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 4| } G_STMT_END | | ------------------ | | | | 882| 4|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 4] | | | | ------------------ | | ------------------ ------------------ 1514| 4| IFACE_NODE_N_PREREQUISITES (iface) < MAX_N_PREREQUISITES && 1515| 4| (prerequisite_node->is_instantiatable || NODE_IS_IFACE (prerequisite_node))); 1516| | 1517| 4| prerequisites = IFACE_NODE_PREREQUISITES (iface); ------------------ | | 262| 4|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 1518| 4| for (i = 0; i < IFACE_NODE_N_PREREQUISITES (iface); i++) ------------------ | | 261| 4|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ | Branch (1518:15): [True: 1, False: 3] ------------------ 1519| 1| if (prerequisites[i] == prerequisite_type) ------------------ | Branch (1519:9): [True: 0, False: 1] ------------------ 1520| 0| return; /* we already have that prerequisiste */ 1521| 1| else if (prerequisites[i] > prerequisite_type) ------------------ | Branch (1521:14): [True: 1, False: 0] ------------------ 1522| 1| break; 1523| 4| IFACE_NODE_N_PREREQUISITES (iface) += 1; ------------------ | | 261| 4|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ 1524| 4| IFACE_NODE_PREREQUISITES (iface) = g_renew (GType, ------------------ | | 262| 4|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ IFACE_NODE_PREREQUISITES (iface) = g_renew (GType, ------------------ | | 321| 4|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 4| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 4|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 4| gsize __n = (gsize) (n_structs); \ | | | | 251| 4| gsize __s = sizeof (struct_type); \ | | | | 252| 4| gpointer __p = (gpointer) (mem); \ | | | | 253| 4| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 4] | | | | ------------------ | | | | 254| 4| __p = g_##func (__p, __n); \ | | | | 255| 4| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 0, False: 4] | | | | ------------------ | | | | 256| 4| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 0] | | | | | Branch (256:26): [True: 0, False: 0] | | | | ------------------ | | | | 257| 4| __p = g_##func (__p, __n * __s); \ | | | | 258| 4| else \ | | | | 259| 4| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 4| __p; \ | | | | 261| 4| })) | | ------------------ ------------------ 1525| 4| IFACE_NODE_PREREQUISITES (iface), 1526| 4| IFACE_NODE_N_PREREQUISITES (iface)); 1527| 4| prerequisites = IFACE_NODE_PREREQUISITES (iface); ------------------ | | 262| 4|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 1528| 4| memmove (prerequisites + i + 1, prerequisites + i, 1529| 4| sizeof (prerequisites[0]) * (IFACE_NODE_N_PREREQUISITES (iface) - i - 1)); ------------------ | | 261| 4|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ 1530| 4| prerequisites[i] = prerequisite_type; 1531| | 1532| | /* we want to get notified when prerequisites get added to prerequisite_node */ 1533| 4| if (NODE_IS_IFACE (prerequisite_node)) ------------------ | | 258| 4|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 4|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 4|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 4|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 4|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 0, False: 4] | | ------------------ ------------------ 1534| 0| { 1535| 0| dependants = iface_node_get_dependants_array_L (prerequisite_node); ------------------ | | 265| 0|#define iface_node_get_dependants_array_L(n) ((GType*) type_get_qdata_L ((n), static_quark_dependants_array)) ------------------ 1536| 0| n_dependants = dependants ? dependants[0] : 0; ------------------ | Branch (1536:22): [True: 0, False: 0] ------------------ 1537| 0| n_dependants += 1; 1538| 0| dependants = g_renew (GType, dependants, n_dependants + 1); ------------------ | | 321| 0|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 0| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 0| gsize __n = (gsize) (n_structs); \ | | | | 251| 0| gsize __s = sizeof (struct_type); \ | | | | 252| 0| gpointer __p = (gpointer) (mem); \ | | | | 253| 0| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 0] | | | | ------------------ | | | | 254| 0| __p = g_##func (__p, __n); \ | | | | 255| 0| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 0, False: 0] | | | | ------------------ | | | | 256| 0| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 0] | | | | | Branch (256:26): [True: 0, False: 0] | | | | ------------------ | | | | 257| 0| __p = g_##func (__p, __n * __s); \ | | | | 258| 0| else \ | | | | 259| 0| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 0| __p; \ | | | | 261| 0| })) | | ------------------ ------------------ 1539| 0| dependants[n_dependants] = NODE_TYPE (iface); ------------------ | | 252| 0|#define NODE_TYPE(node) (node->supers[0]) ------------------ 1540| 0| dependants[0] = n_dependants; 1541| 0| iface_node_set_dependants_array_W (prerequisite_node, dependants); ------------------ | | 266| 0|#define iface_node_set_dependants_array_W(n,d) (type_set_qdata_W ((n), static_quark_dependants_array, (d))) ------------------ 1542| 0| } 1543| | 1544| | /* we need to notify all dependants */ 1545| 4| dependants = iface_node_get_dependants_array_L (iface); ------------------ | | 265| 4|#define iface_node_get_dependants_array_L(n) ((GType*) type_get_qdata_L ((n), static_quark_dependants_array)) ------------------ 1546| 4| n_dependants = dependants ? dependants[0] : 0; ------------------ | Branch (1546:18): [True: 0, False: 4] ------------------ 1547| 4| for (i = 1; i <= n_dependants; i++) ------------------ | Branch (1547:15): [True: 0, False: 4] ------------------ 1548| 0| type_iface_add_prerequisite_W (lookup_type_node_I (dependants[i]), prerequisite_node); 1549| 4|} gtype.c:check_type_name_I: 743| 97|{ 744| 97| static const gchar extra_chars[] = "-_+"; 745| 97| const gchar *p = type_name; 746| 97| gboolean name_valid; 747| | 748| 97| if (!type_name[0] || !type_name[1] || !type_name[2]) ------------------ | Branch (748:7): [True: 0, False: 97] | Branch (748:24): [True: 0, False: 97] | Branch (748:41): [True: 0, False: 97] ------------------ 749| 0| { 750| 0| g_warning ("type name '%s' is too short", type_name); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 751| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 752| 0| } 753| | /* check the first letter */ 754| 97| name_valid = (p[0] >= 'A' && p[0] <= 'Z') || (p[0] >= 'a' && p[0] <= 'z') || p[0] == '_'; ------------------ | Branch (754:17): [True: 97, False: 0] | Branch (754:32): [True: 71, False: 26] | Branch (754:49): [True: 26, False: 0] | Branch (754:64): [True: 26, False: 0] | Branch (754:80): [True: 0, False: 0] ------------------ 755| 923| for (p = type_name + 1; *p; p++) ------------------ | Branch (755:27): [True: 826, False: 97] ------------------ 756| 826| name_valid &= ((p[0] >= 'A' && p[0] <= 'Z') || ------------------ | Branch (756:21): [True: 810, False: 16] | Branch (756:36): [True: 139, False: 671] ------------------ 757| 687| (p[0] >= 'a' && p[0] <= 'z') || ------------------ | Branch (757:7): [True: 671, False: 16] | Branch (757:22): [True: 671, False: 0] ------------------ 758| 16| (p[0] >= '0' && p[0] <= '9') || ------------------ | Branch (758:7): [True: 16, False: 0] | Branch (758:22): [True: 16, False: 0] ------------------ 759| 0| strchr (extra_chars, p[0])); ------------------ | Branch (759:6): [True: 0, False: 0] ------------------ 760| 97| if (!name_valid) ------------------ | Branch (760:7): [True: 0, False: 97] ------------------ 761| 0| { 762| 0| g_warning ("type name '%s' contains invalid characters", type_name); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 763| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 764| 0| } 765| 97| if (g_type_from_name (type_name)) ------------------ | Branch (765:7): [True: 0, False: 97] ------------------ 766| 0| { 767| 0| g_warning ("cannot register existing type '%s'", type_name); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 768| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 769| 0| } 770| | 771| 97| return TRUE; ------------------ | | 818| 97|#define TRUE (!FALSE) | | ------------------ | | | | 814| 97|#define FALSE (0) | | ------------------ ------------------ 772| 97|} gtype.c:type_node_fundamental_new_W: 542| 42|{ 543| 42| GTypeFundamentalInfo *finfo; 544| 42| TypeNode *node; 545| | 546| 42| g_assert ((ftype & TYPE_ID_MASK) == 0); ------------------ | | 231| 42|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 42|#define G_STMT_START do | | ------------------ | | 232| 42| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 42|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 42| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 42|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 42| int _g_boolean_var_; \ | | | | | | 1018| 42| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 42, False: 0] | | | | | | ------------------ | | | | | | 1019| 42| _g_boolean_var_ = 1; \ | | | | | | 1020| 42| else \ | | | | | | 1021| 42| _g_boolean_var_ = 0; \ | | | | | | 1022| 42| _g_boolean_var_; \ | | | | | | 1023| 42|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 42, False: 0] | | | | ------------------ | | ------------------ | | 233| 42| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 42| } G_STMT_END | | ------------------ | | | | 882| 42|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 42] | | | | ------------------ | | ------------------ ------------------ 547| 42| g_assert (ftype <= G_TYPE_FUNDAMENTAL_MAX); ------------------ | | 231| 42|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 42|#define G_STMT_START do | | ------------------ | | 232| 42| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 42|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 42| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 42|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 42| int _g_boolean_var_; \ | | | | | | 1018| 42| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 42, False: 0] | | | | | | ------------------ | | | | | | 1019| 42| _g_boolean_var_ = 1; \ | | | | | | 1020| 42| else \ | | | | | | 1021| 42| _g_boolean_var_ = 0; \ | | | | | | 1022| 42| _g_boolean_var_; \ | | | | | | 1023| 42|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 42, False: 0] | | | | ------------------ | | ------------------ | | 233| 42| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 42| } G_STMT_END | | ------------------ | | | | 882| 42|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 42] | | | | ------------------ | | ------------------ ------------------ 548| | 549| 42| if (ftype >> G_TYPE_FUNDAMENTAL_SHIFT == static_fundamental_next) ------------------ | | 210| 42|#define G_TYPE_FUNDAMENTAL_SHIFT (2) ------------------ | Branch (549:7): [True: 0, False: 42] ------------------ 550| 0| static_fundamental_next++; 551| | 552| 42| type_flags &= TYPE_FUNDAMENTAL_FLAG_MASK; ------------------ | | 142| 42|#define TYPE_FUNDAMENTAL_FLAG_MASK (G_TYPE_FLAG_CLASSED | \ | | 143| 42| G_TYPE_FLAG_INSTANTIATABLE | \ | | 144| 42| G_TYPE_FLAG_DERIVABLE | \ | | 145| 42| G_TYPE_FLAG_DEEP_DERIVABLE) ------------------ 553| | 554| 42| node = type_node_any_new_W (NULL, ftype, name, NULL, type_flags); 555| | 556| 42| finfo = type_node_fundamental_info_I (node); 557| 42| finfo->type_flags = type_flags; 558| | 559| 42| return node; 560| 42|} gtype.c:type_node_any_new_W: 427| 101|{ 428| 101| guint n_supers; 429| 101| GType type; 430| 101| TypeNode *node; 431| 101| guint i, node_size = 0; 432| | 433| 101| n_supers = pnode ? pnode->n_supers + 1 : 0; ------------------ | Branch (433:14): [True: 59, False: 42] ------------------ 434| | 435| 101| if (!pnode) ------------------ | Branch (435:7): [True: 42, False: 59] ------------------ 436| 42| node_size += SIZEOF_FUNDAMENTAL_INFO; /* fundamental type info */ ------------------ | | 147| 42|#define SIZEOF_FUNDAMENTAL_INFO ((gssize) MAX (MAX (sizeof (GTypeFundamentalInfo), \ | | ------------------ | | | | 822| 84|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | | | ------------------ | | | | | Branch (822:21): [Folded, False: 42] | | | | | Branch (822:23): [Folded, False: 42] | | | | | Branch (822:36): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 148| 42| sizeof (gpointer)), \ | | 149| 42| sizeof (glong))) ------------------ 437| 101| node_size += SIZEOF_BASE_TYPE_NODE (); /* TypeNode structure */ ------------------ | | 247| 101|#define SIZEOF_BASE_TYPE_NODE() (G_STRUCT_OFFSET (TypeNode, supers)) | | ------------------ | | | | 853| 101| ((glong) offsetof (struct_type, member)) | | ------------------ ------------------ 438| 101| node_size += (sizeof (GType) * (1 + n_supers + 1)); /* self + ancestors + (0) for ->supers[] */ 439| 101| node = g_malloc0 (node_size); 440| 101| if (!pnode) /* offset fundamental types */ ------------------ | Branch (440:7): [True: 42, False: 59] ------------------ 441| 42| { 442| 42| node = G_STRUCT_MEMBER_P (node, SIZEOF_FUNDAMENTAL_INFO); ------------------ | | 860| 168| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ | | | Branch (860:50): [Folded, False: 42] | | | Branch (860:50): [Folded, False: 0] | | | Branch (860:50): [Folded, False: 42] | | ------------------ ------------------ 443| 42| static_fundamental_type_nodes[ftype >> G_TYPE_FUNDAMENTAL_SHIFT] = node; ------------------ | | 210| 42|#define G_TYPE_FUNDAMENTAL_SHIFT (2) ------------------ 444| 42| type = ftype; 445| | 446| 42|#if ENABLE_VALGRIND 447| 42| VALGRIND_MALLOCLIKE_BLOCK (node, node_size - SIZEOF_FUNDAMENTAL_INFO, FALSE, TRUE); ------------------ | | 6479| 42| VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__MALLOCLIKE_BLOCK, \ | | ------------------ | | | | 203| 42| do { (void) VALGRIND_DO_CLIENT_REQUEST_EXPR(0, \ | | | | ------------------ | | | | | | 413| 42| __extension__ \ | | | | | | 414| 42| ({ volatile unsigned long int _zzq_args[6]; \ | | | | | | 415| 42| volatile unsigned long int _zzq_result; \ | | | | | | 416| 42| _zzq_args[0] = (unsigned long int)(_zzq_request); \ | | | | | | 417| 42| _zzq_args[1] = (unsigned long int)(_zzq_arg1); \ | | | | | | 418| 168| _zzq_args[2] = (unsigned long int)(_zzq_arg2); \ | | | | | | ------------------ | | | | | | | Branch (418:40): [Folded, False: 42] | | | | | | | Branch (418:40): [Folded, False: 0] | | | | | | | Branch (418:40): [Folded, False: 42] | | | | | | ------------------ | | | | | | 419| 42| _zzq_args[3] = (unsigned long int)(_zzq_arg3); \ | | | | | | 420| 42| _zzq_args[4] = (unsigned long int)(_zzq_arg4); \ | | | | | | 421| 42| _zzq_args[5] = (unsigned long int)(_zzq_arg5); \ | | | | | | 422| 42| __asm__ volatile(__SPECIAL_INSTRUCTION_PREAMBLE \ | | | | | | 423| 42| /* %RDX = client_request ( %RAX ) */ \ | | | | | | 424| 42| "xchgq %%rbx,%%rbx" \ | | | | | | 425| 42| : "=d" (_zzq_result) \ | | | | | | 426| 42| : "a" (&_zzq_args[0]), "0" (_zzq_default) \ | | | | | | 427| 42| : "cc", "memory" \ | | | | | | 428| 42| ); \ | | | | | | 429| 42| _zzq_result; \ | | | | | | 430| 42| }) | | | | ------------------ | | | | 204| 42| (_zzq_request), (_zzq_arg1), (_zzq_arg2), \ | | | | 205| 42| (_zzq_arg3), (_zzq_arg4), (_zzq_arg5)); } while (0) | | | | ------------------ | | | | | Branch (205:70): [Folded, False: 42] | | | | ------------------ | | ------------------ | | 6480| 42| addr, sizeB, rzB, is_zeroed, 0) ------------------ 448| 42|#endif 449| 42| } 450| 59| else 451| 59| type = (GType) node; 452| | 453| 101| g_assert ((type & TYPE_ID_MASK) == 0); ------------------ | | 231| 101|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 101|#define G_STMT_START do | | ------------------ | | 232| 101| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 101|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 101| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 101|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 101| int _g_boolean_var_; \ | | | | | | 1018| 101| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 101, False: 0] | | | | | | ------------------ | | | | | | 1019| 101| _g_boolean_var_ = 1; \ | | | | | | 1020| 101| else \ | | | | | | 1021| 101| _g_boolean_var_ = 0; \ | | | | | | 1022| 101| _g_boolean_var_; \ | | | | | | 1023| 101|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 101, False: 0] | | | | ------------------ | | ------------------ | | 233| 101| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 101| } G_STMT_END | | ------------------ | | | | 882| 101|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 101] | | | | ------------------ | | ------------------ ------------------ 454| | 455| 101| node->n_supers = n_supers; 456| 101| if (!pnode) ------------------ | Branch (456:7): [True: 42, False: 59] ------------------ 457| 42| { 458| 42| node->supers[0] = type; 459| 42| node->supers[1] = 0; 460| | 461| 42| node->is_classed = (type_flags & G_TYPE_FLAG_CLASSED) != 0; 462| 42| node->is_instantiatable = (type_flags & G_TYPE_FLAG_INSTANTIATABLE) != 0; 463| | 464| 42| if (NODE_IS_IFACE (node)) ------------------ | | 258| 42|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 42|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 42|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 42|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 42|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 2, False: 40] | | ------------------ ------------------ 465| 2| { 466| 2| IFACE_NODE_N_PREREQUISITES (node) = 0; ------------------ | | 261| 2|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ 467| 2| IFACE_NODE_PREREQUISITES (node) = NULL; ------------------ | | 262| 2|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 468| 2| } 469| 40| else 470| 40| _g_atomic_array_init (CLASSED_NODE_IFACES_ENTRIES (node)); ------------------ | | 259| 40|#define CLASSED_NODE_IFACES_ENTRIES(node) (&(node)->_prot.iface_entries) ------------------ 471| 42| } 472| 59| else 473| 59| { 474| 59| node->supers[0] = type; 475| 59| memcpy (node->supers + 1, pnode->supers, sizeof (GType) * (1 + pnode->n_supers + 1)); 476| | 477| 59| node->is_classed = pnode->is_classed; 478| 59| node->is_instantiatable = pnode->is_instantiatable; 479| | 480| 59| if (NODE_IS_IFACE (node)) ------------------ | | 258| 59|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 59|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 59|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 59|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 59|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 5, False: 54] | | ------------------ ------------------ 481| 5| { 482| 5| IFACE_NODE_N_PREREQUISITES (node) = 0; ------------------ | | 261| 5|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ 483| 5| IFACE_NODE_PREREQUISITES (node) = NULL; ------------------ | | 262| 5|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 484| 5| } 485| 54| else 486| 54| { 487| 54| guint j; 488| 54| IFaceEntries *entries; 489| | 490| 54| entries = _g_atomic_array_copy (CLASSED_NODE_IFACES_ENTRIES (pnode), ------------------ | | 259| 54|#define CLASSED_NODE_IFACES_ENTRIES(node) (&(node)->_prot.iface_entries) ------------------ 491| 54| IFACE_ENTRIES_HEADER_SIZE, ------------------ | | 293| 54|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) ------------------ 492| 54| 0); 493| 54| if (entries) ------------------ | Branch (493:8): [True: 1, False: 53] ------------------ 494| 1| { 495| 2| for (j = 0; j < IFACE_ENTRIES_N_ENTRIES (entries); j++) ------------------ | | 294| 2|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 2|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 2|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (495:20): [True: 1, False: 1] ------------------ 496| 1| { 497| 1| entries->entry[j].vtable = NULL; 498| 1| entries->entry[j].init_state = UNINITIALIZED; 499| 1| } 500| 1| _g_atomic_array_update (CLASSED_NODE_IFACES_ENTRIES (node), ------------------ | | 259| 1|#define CLASSED_NODE_IFACES_ENTRIES(node) (&(node)->_prot.iface_entries) ------------------ 501| 1| entries); 502| 1| } 503| 54| } 504| | 505| 59| i = pnode->n_children++; 506| 59| pnode->children = g_renew (GType, pnode->children, pnode->n_children); ------------------ | | 321| 59|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 59| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 59| gsize __n = (gsize) (n_structs); \ | | | | 251| 59| gsize __s = sizeof (struct_type); \ | | | | 252| 59| gpointer __p = (gpointer) (mem); \ | | | | 253| 59| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 59] | | | | ------------------ | | | | 254| 59| __p = g_##func (__p, __n); \ | | | | 255| 59| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 0, False: 59] | | | | ------------------ | | | | 256| 59| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 0] | | | | | Branch (256:26): [True: 0, False: 0] | | | | ------------------ | | | | 257| 59| __p = g_##func (__p, __n * __s); \ | | | | 258| 59| else \ | | | | 259| 59| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 59| __p; \ | | | | 261| 59| })) | | ------------------ ------------------ 507| 59| pnode->children[i] = type; 508| 59| } 509| | 510| 101| TRACE(GOBJECT_TYPE_NEW(name, node->supers[1], type)); 511| | 512| 101| node->plugin = plugin; 513| 101| node->n_children = 0; 514| 101| node->children = NULL; 515| 101| node->data = NULL; 516| 101| node->qname = g_quark_from_string (name); 517| 101| node->global_gdata = NULL; 518| 101| g_hash_table_insert (static_type_nodes_ht, 519| 101| (gpointer) g_quark_to_string (node->qname), 520| 101| (gpointer) type); 521| | 522| 101| g_atomic_int_inc ((gint *)&type_registration_serial); ------------------ | | 148| 101| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 101|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 149| 101| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 101|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 150| 101| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (150:13): [Folded, False: 101] | | ------------------ | | 151| 101| (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ | | 152| 101| })) ------------------ 523| | 524| 101| return node; 525| 101|} gtype.c:check_type_info_I: 892| 97|{ 893| 97| GTypeFundamentalInfo *finfo = type_node_fundamental_info_I (lookup_type_node_I (ftype)); 894| 97| gboolean is_interface = ftype == G_TYPE_INTERFACE; ------------------ | | 68| 97|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | ------------------ | | | | 221| 97|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 97|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 895| | 896| 97| g_assert (ftype <= G_TYPE_FUNDAMENTAL_MAX && !(ftype & TYPE_ID_MASK)); ------------------ | | 231| 97|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 97|#define G_STMT_START do | | ------------------ | | 232| 97| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 97|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 97| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 97|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 97| int _g_boolean_var_; \ | | | | | | 1018| 291| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 97, False: 0] | | | | | | | Branch (1018:8): [True: 97, False: 0] | | | | | | ------------------ | | | | | | 1019| 97| _g_boolean_var_ = 1; \ | | | | | | 1020| 97| else \ | | | | | | 1021| 97| _g_boolean_var_ = 0; \ | | | | | | 1022| 97| _g_boolean_var_; \ | | | | | | 1023| 97|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 97, False: 0] | | | | ------------------ | | ------------------ | | 233| 97| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 97| } G_STMT_END | | ------------------ | | | | 882| 97|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 97] | | | | ------------------ | | ------------------ ------------------ 897| | 898| | /* check instance members */ 899| 97| if (!(finfo->type_flags & G_TYPE_FLAG_INSTANTIATABLE) && ------------------ | Branch (899:7): [True: 43, False: 54] ------------------ 900| 43| (info->instance_size || info->n_preallocs || info->instance_init)) ------------------ | Branch (900:8): [True: 0, False: 43] | Branch (900:31): [True: 0, False: 43] | Branch (900:52): [True: 0, False: 43] ------------------ 901| 0| { 902| 0| if (pnode) ------------------ | Branch (902:11): [True: 0, False: 0] ------------------ 903| 0| g_warning ("cannot instantiate '%s', derived from non-instantiatable parent type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 904| 0| type_name, 905| 0| NODE_NAME (pnode)); 906| 0| else 907| 0| g_warning ("cannot instantiate '%s' as non-instantiatable fundamental", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 908| 0| type_name); 909| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 910| 0| } 911| | /* check class & interface members */ 912| 97| if (!((finfo->type_flags & G_TYPE_FLAG_CLASSED) || is_interface) && ------------------ | Branch (912:9): [True: 58, False: 39] | Branch (912:54): [True: 5, False: 34] ------------------ 913| 34| (info->class_init || info->class_finalize || info->class_data || ------------------ | Branch (913:8): [True: 0, False: 34] | Branch (913:28): [True: 0, False: 34] | Branch (913:52): [True: 0, False: 34] ------------------ 914| 34| info->class_size || info->base_init || info->base_finalize)) ------------------ | Branch (914:8): [True: 0, False: 34] | Branch (914:28): [True: 0, False: 34] | Branch (914:47): [True: 0, False: 34] ------------------ 915| 0| { 916| 0| if (pnode) ------------------ | Branch (916:11): [True: 0, False: 0] ------------------ 917| 0| g_warning ("cannot create class for '%s', derived from non-classed parent type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 918| 0| type_name, 919| 0| NODE_NAME (pnode)); 920| 0| else 921| 0| g_warning ("cannot create class for '%s' as non-classed fundamental", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 922| 0| type_name); 923| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 924| 0| } 925| | /* check interface size */ 926| 97| if (is_interface && info->class_size < sizeof (GTypeInterface)) ------------------ | Branch (926:7): [True: 5, False: 92] | Branch (926:23): [True: 0, False: 5] ------------------ 927| 0| { 928| 0| g_warning ("specified interface size for type '%s' is smaller than 'GTypeInterface' size", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 929| 0| type_name); 930| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 931| 0| } 932| | /* check class size */ 933| 97| if (finfo->type_flags & G_TYPE_FLAG_CLASSED) ------------------ | Branch (933:7): [True: 58, False: 39] ------------------ 934| 58| { 935| 58| if (info->class_size < sizeof (GTypeClass)) ------------------ | Branch (935:11): [True: 0, False: 58] ------------------ 936| 0| { 937| 0| g_warning ("specified class size for type '%s' is smaller than 'GTypeClass' size", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 938| 0| type_name); 939| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 940| 0| } 941| 58| if (pnode && info->class_size < pnode->data->class.class_size) ------------------ | Branch (941:11): [True: 50, False: 8] | Branch (941:20): [True: 0, False: 50] ------------------ 942| 0| { 943| 0| g_warning ("specified class size for type '%s' is smaller " ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 944| 0| "than the parent type's '%s' class size", 945| 0| type_name, 946| 0| NODE_NAME (pnode)); 947| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 948| 0| } 949| 58| } 950| | /* check instance size */ 951| 97| if (finfo->type_flags & G_TYPE_FLAG_INSTANTIATABLE) ------------------ | Branch (951:7): [True: 54, False: 43] ------------------ 952| 54| { 953| 54| if (info->instance_size < sizeof (GTypeInstance)) ------------------ | Branch (953:11): [True: 0, False: 54] ------------------ 954| 0| { 955| 0| g_warning ("specified instance size for type '%s' is smaller than 'GTypeInstance' size", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 956| 0| type_name); 957| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 958| 0| } 959| 54| if (pnode && info->instance_size < pnode->data->instance.instance_size) ------------------ | Branch (959:11): [True: 50, False: 4] | Branch (959:20): [True: 0, False: 50] ------------------ 960| 0| { 961| 0| g_warning ("specified instance size for type '%s' is smaller " ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 962| 0| "than the parent type's '%s' instance size", 963| 0| type_name, 964| 0| NODE_NAME (pnode)); 965| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 966| 0| } 967| 54| } 968| | 969| 97| return TRUE; ------------------ | | 818| 97|#define TRUE (!FALSE) | | ------------------ | | | | 814| 97|#define FALSE (0) | | ------------------ ------------------ 970| 97|} gtype.c:type_data_make_W: 1088| 99|{ 1089| 99| TypeData *data; 1090| 99| GTypeValueTable *vtable = NULL; 1091| 99| guint vtable_size = 0; 1092| | 1093| 99| g_assert (node->data == NULL && info != NULL); ------------------ | | 231| 99|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 99|#define G_STMT_START do | | ------------------ | | 232| 99| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 99|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 99| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 99|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 99| int _g_boolean_var_; \ | | | | | | 1018| 297| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 99, False: 0] | | | | | | | Branch (1018:8): [True: 99, False: 0] | | | | | | ------------------ | | | | | | 1019| 99| _g_boolean_var_ = 1; \ | | | | | | 1020| 99| else \ | | | | | | 1021| 99| _g_boolean_var_ = 0; \ | | | | | | 1022| 99| _g_boolean_var_; \ | | | | | | 1023| 99|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 99, False: 0] | | | | ------------------ | | ------------------ | | 233| 99| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 99| } G_STMT_END | | ------------------ | | | | 882| 99|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 99] | | | | ------------------ | | ------------------ ------------------ 1094| | 1095| 99| if (!value_table) ------------------ | Branch (1095:7): [True: 61, False: 38] ------------------ 1096| 61| { 1097| 61| TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 61|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 1098| | 1099| 61| if (pnode) ------------------ | Branch (1099:11): [True: 57, False: 4] ------------------ 1100| 57| vtable = pnode->data->common.value_table; 1101| 4| else 1102| 4| { 1103| 4| static const GTypeValueTable zero_vtable = { NULL, }; 1104| | 1105| 4| value_table = &zero_vtable; 1106| 4| } 1107| 61| } 1108| 99| if (value_table) ------------------ | Branch (1108:7): [True: 42, False: 57] ------------------ 1109| 42| { 1110| | /* need to setup vtable_size since we have to allocate it with data in one chunk */ 1111| 42| vtable_size = sizeof (GTypeValueTable); 1112| 42| if (value_table->collect_format) ------------------ | Branch (1112:11): [True: 38, False: 4] ------------------ 1113| 38| vtable_size += strlen (value_table->collect_format); 1114| 42| if (value_table->lcopy_format) ------------------ | Branch (1114:11): [True: 38, False: 4] ------------------ 1115| 38| vtable_size += strlen (value_table->lcopy_format); 1116| 42| vtable_size += 2; 1117| 42| } 1118| | 1119| 99| if (node->is_instantiatable) /* careful, is_instantiatable is also is_classed */ ------------------ | Branch (1119:7): [True: 54, False: 45] ------------------ 1120| 54| { 1121| 54| TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 54|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 1122| | 1123| 54| data = g_malloc0 (sizeof (InstanceData) + vtable_size); 1124| 54| if (vtable_size) ------------------ | Branch (1124:11): [True: 4, False: 50] ------------------ 1125| 4| vtable = G_STRUCT_MEMBER_P (data, sizeof (InstanceData)); ------------------ | | 860| 4| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1126| 54| data->instance.class_size = info->class_size; 1127| 54| data->instance.class_init_base = info->base_init; 1128| 54| data->instance.class_finalize_base = info->base_finalize; 1129| 54| data->instance.class_init = info->class_init; 1130| 54| data->instance.class_finalize = info->class_finalize; 1131| 54| data->instance.class_data = info->class_data; 1132| 54| data->instance.class = NULL; 1133| 54| data->instance.init_state = UNINITIALIZED; 1134| 54| data->instance.instance_size = info->instance_size; 1135| | /* We'll set the final value for data->instance.private size 1136| | * after the parent class has been initialized 1137| | */ 1138| 54| data->instance.private_size = 0; 1139| 54| data->instance.class_private_size = 0; 1140| 54| if (pnode) ------------------ | Branch (1140:11): [True: 50, False: 4] ------------------ 1141| 50| data->instance.class_private_size = pnode->data->instance.class_private_size; 1142| 54| data->instance.n_preallocs = MIN (info->n_preallocs, 1024); ------------------ | | 825| 54|#define MIN(a, b) (((a) < (b)) ? (a) : (b)) | | ------------------ | | | Branch (825:21): [True: 54, False: 0] | | ------------------ ------------------ 1143| 54| data->instance.instance_init = info->instance_init; 1144| 54| } 1145| 45| else if (node->is_classed) /* only classed */ ------------------ | Branch (1145:12): [True: 4, False: 41] ------------------ 1146| 4| { 1147| 4| TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 4|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 1148| | 1149| 4| data = g_malloc0 (sizeof (ClassData) + vtable_size); 1150| 4| if (vtable_size) ------------------ | Branch (1150:11): [True: 4, False: 0] ------------------ 1151| 4| vtable = G_STRUCT_MEMBER_P (data, sizeof (ClassData)); ------------------ | | 860| 4| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1152| 4| data->class.class_size = info->class_size; 1153| 4| data->class.class_init_base = info->base_init; 1154| 4| data->class.class_finalize_base = info->base_finalize; 1155| 4| data->class.class_init = info->class_init; 1156| 4| data->class.class_finalize = info->class_finalize; 1157| 4| data->class.class_data = info->class_data; 1158| 4| data->class.class = NULL; 1159| 4| data->class.class_private_size = 0; 1160| 4| if (pnode) ------------------ | Branch (1160:11): [True: 0, False: 4] ------------------ 1161| 0| data->class.class_private_size = pnode->data->class.class_private_size; 1162| 4| data->class.init_state = UNINITIALIZED; 1163| 4| } 1164| 41| else if (NODE_IS_IFACE (node)) ------------------ | | 258| 41|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 41|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 41|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 41|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 41|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 7, False: 34] | | ------------------ ------------------ 1165| 7| { 1166| 7| data = g_malloc0 (sizeof (IFaceData) + vtable_size); 1167| 7| if (vtable_size) ------------------ | Branch (1167:11): [True: 2, False: 5] ------------------ 1168| 2| vtable = G_STRUCT_MEMBER_P (data, sizeof (IFaceData)); ------------------ | | 860| 2| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1169| 7| data->iface.vtable_size = info->class_size; 1170| 7| data->iface.vtable_init_base = info->base_init; 1171| 7| data->iface.vtable_finalize_base = info->base_finalize; 1172| 7| data->iface.dflt_init = info->class_init; 1173| 7| data->iface.dflt_finalize = info->class_finalize; 1174| 7| data->iface.dflt_data = info->class_data; 1175| 7| data->iface.dflt_vtable = NULL; 1176| 7| } 1177| 34| else if (NODE_IS_BOXED (node)) ------------------ | | 257| 34|#define NODE_IS_BOXED(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_BOXED) | | ------------------ | | | | 254| 34|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_BOXED(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_BOXED) | | ------------------ | | | | 166| 34|#define G_TYPE_BOXED G_TYPE_MAKE_FUNDAMENTAL (18) | | | | ------------------ | | | | | | 221| 34|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 34|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (257:31): [True: 4, False: 30] | | ------------------ ------------------ 1178| 4| { 1179| 4| data = g_malloc0 (sizeof (BoxedData) + vtable_size); 1180| 4| if (vtable_size) ------------------ | Branch (1180:11): [True: 4, False: 0] ------------------ 1181| 4| vtable = G_STRUCT_MEMBER_P (data, sizeof (BoxedData)); ------------------ | | 860| 4| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1182| 4| } 1183| 30| else 1184| 30| { 1185| 30| data = g_malloc0 (sizeof (CommonData) + vtable_size); 1186| 30| if (vtable_size) ------------------ | Branch (1186:11): [True: 28, False: 2] ------------------ 1187| 28| vtable = G_STRUCT_MEMBER_P (data, sizeof (CommonData)); ------------------ | | 860| 28| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1188| 30| } 1189| | 1190| 99| node->data = data; 1191| | 1192| 99| if (vtable_size) ------------------ | Branch (1192:7): [True: 42, False: 57] ------------------ 1193| 42| { 1194| 42| gchar *p; 1195| | 1196| | /* we allocate the vtable and its strings together with the type data, so 1197| | * children can take over their parent's vtable pointer, and we don't 1198| | * need to worry freeing it or not when the child data is destroyed 1199| | */ 1200| 42| *vtable = *value_table; 1201| 42| p = G_STRUCT_MEMBER_P (vtable, sizeof (*vtable)); ------------------ | | 860| 42| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1202| 42| p[0] = 0; 1203| 42| vtable->collect_format = p; 1204| 42| if (value_table->collect_format) ------------------ | Branch (1204:11): [True: 38, False: 4] ------------------ 1205| 38| { 1206| 38| strcat (p, value_table->collect_format); 1207| 38| p += strlen (value_table->collect_format); 1208| 38| } 1209| 42| p++; 1210| 42| p[0] = 0; 1211| 42| vtable->lcopy_format = p; 1212| 42| if (value_table->lcopy_format) ------------------ | Branch (1212:11): [True: 38, False: 4] ------------------ 1213| 38| strcat (p, value_table->lcopy_format); 1214| 42| } 1215| 99| node->data->common.value_table = vtable; 1216| 99| node->mutatable_check_cache = (node->data->common.value_table->value_init != NULL && ------------------ | Branch (1216:34): [True: 90, False: 9] ------------------ 1217| 90| !((G_TYPE_FLAG_VALUE_ABSTRACT | G_TYPE_FLAG_ABSTRACT) & ------------------ | Branch (1217:6): [True: 83, False: 7] ------------------ 1218| 90| GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags)))); ------------------ | | 99| 90|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 1219| | 1220| 99| g_assert (node->data->common.value_table != NULL); /* paranoid */ ------------------ | | 231| 99|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 99|#define G_STMT_START do | | ------------------ | | 232| 99| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 99|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 99| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 99|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 99| int _g_boolean_var_; \ | | | | | | 1018| 99| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 99, False: 0] | | | | | | ------------------ | | | | | | 1019| 99| _g_boolean_var_ = 1; \ | | | | | | 1020| 99| else \ | | | | | | 1021| 99| _g_boolean_var_ = 0; \ | | | | | | 1022| 99| _g_boolean_var_; \ | | | | | | 1023| 99|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 99, False: 0] | | | | ------------------ | | ------------------ | | 233| 99| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 99| } G_STMT_END | | ------------------ | | | | 882| 99|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 99] | | | | ------------------ | | ------------------ ------------------ 1221| | 1222| 99| g_atomic_int_set ((int *) &node->ref_count, 1); ------------------ | | 104| 99| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 99|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 105| 99| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 99|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 106| 99| gint gais_temp = (gint) (newval); \ | | 107| 99| (void) (0 ? *(atomic) ^ (newval) : 1); \ | | ------------------ | | | Branch (107:13): [Folded, False: 99] | | ------------------ | | 108| 99| __atomic_store ((gint *)(atomic), &gais_temp, __ATOMIC_SEQ_CST); \ | | 109| 99| })) ------------------ 1223| 99|} gtype.c:check_value_table_I: 828| 97|{ 829| 97| if (!value_table) ------------------ | Branch (829:7): [True: 59, False: 38] ------------------ 830| 59| return FALSE; ------------------ | | 814| 59|#define FALSE (0) ------------------ 831| 38| else if (value_table->value_init == NULL) ------------------ | Branch (831:12): [True: 0, False: 38] ------------------ 832| 0| { 833| 0| if (value_table->value_free || value_table->value_copy || ------------------ | Branch (833:11): [True: 0, False: 0] | Branch (833:38): [True: 0, False: 0] ------------------ 834| 0| value_table->value_peek_pointer || ------------------ | Branch (834:4): [True: 0, False: 0] ------------------ 835| 0| value_table->collect_format || value_table->collect_value || ------------------ | Branch (835:4): [True: 0, False: 0] | Branch (835:35): [True: 0, False: 0] ------------------ 836| 0| value_table->lcopy_format || value_table->lcopy_value) ------------------ | Branch (836:4): [True: 0, False: 0] | Branch (836:33): [True: 0, False: 0] ------------------ 837| 0| g_warning ("cannot handle uninitializable values of type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 838| 0| type_name); 839| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 840| 0| } 841| 38| else /* value_table->value_init != NULL */ 842| 38| { 843| 38| if (!value_table->value_free) ------------------ | Branch (843:11): [True: 28, False: 10] ------------------ 844| 28| { 845| | /* +++ optional +++ 846| | * g_warning ("missing 'value_free()' for type '%s'", type_name); 847| | * return FALSE; 848| | */ 849| 28| } 850| 38| if (!value_table->value_copy) ------------------ | Branch (850:11): [True: 0, False: 38] ------------------ 851| 0| { 852| 0| g_warning ("missing 'value_copy()' for type '%s'", type_name); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 853| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 854| 0| } 855| 38| if ((value_table->collect_format || value_table->collect_value) && ------------------ | Branch (855:12): [True: 38, False: 0] | Branch (855:43): [True: 0, False: 0] ------------------ 856| 38| (!value_table->collect_format || !value_table->collect_value)) ------------------ | Branch (856:5): [True: 0, False: 38] | Branch (856:37): [True: 0, False: 38] ------------------ 857| 0| { 858| 0| g_warning ("one of 'collect_format' and 'collect_value()' is unspecified for type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 859| 0| type_name); 860| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 861| 0| } 862| 38| if (value_table->collect_format && !check_collect_format_I (value_table->collect_format)) ------------------ | Branch (862:11): [True: 38, False: 0] | Branch (862:42): [True: 0, False: 38] ------------------ 863| 0| { 864| 0| g_warning ("the '%s' specification for type '%s' is too long or invalid", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 865| 0| "collect_format", 866| 0| type_name); 867| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 868| 0| } 869| 38| if ((value_table->lcopy_format || value_table->lcopy_value) && ------------------ | Branch (869:12): [True: 38, False: 0] | Branch (869:41): [True: 0, False: 0] ------------------ 870| 38| (!value_table->lcopy_format || !value_table->lcopy_value)) ------------------ | Branch (870:5): [True: 0, False: 38] | Branch (870:35): [True: 0, False: 38] ------------------ 871| 0| { 872| 0| g_warning ("one of 'lcopy_format' and 'lcopy_value()' is unspecified for type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 873| 0| type_name); 874| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 875| 0| } 876| 38| if (value_table->lcopy_format && !check_collect_format_I (value_table->lcopy_format)) ------------------ | Branch (876:11): [True: 38, False: 0] | Branch (876:40): [True: 0, False: 38] ------------------ 877| 0| { 878| 0| g_warning ("the '%s' specification for type '%s' is too long or invalid", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 879| 0| "lcopy_format", 880| 0| type_name); 881| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 882| 0| } 883| 38| } 884| 38| return TRUE; ------------------ | | 818| 38|#define TRUE (!FALSE) | | ------------------ | | | | 814| 38|#define FALSE (0) | | ------------------ ------------------ 885| 97|} gtype.c:check_collect_format_I: 813| 76|{ 814| 76| const gchar *p = collect_format; 815| 76| gchar valid_format[] = { G_VALUE_COLLECT_INT, G_VALUE_COLLECT_LONG, 816| 76| G_VALUE_COLLECT_INT64, G_VALUE_COLLECT_DOUBLE, 817| 76| G_VALUE_COLLECT_POINTER, 0 }; 818| | 819| 152| while (*p) ------------------ | Branch (819:10): [True: 76, False: 76] ------------------ 820| 76| if (!strchr (valid_format, *p++)) ------------------ | Branch (820:9): [True: 0, False: 76] ------------------ 821| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 822| 76| return p - collect_format <= G_VALUE_COLLECT_FORMAT_MAX_LENGTH; ------------------ | | 257| 76|#define G_VALUE_COLLECT_FORMAT_MAX_LENGTH (8) ------------------ 823| 76|} gtype.c:check_derivation_I: 777| 59|{ 778| 59| TypeNode *pnode; 779| 59| GTypeFundamentalInfo* finfo; 780| | 781| 59| pnode = lookup_type_node_I (parent_type); 782| 59| if (!pnode) ------------------ | Branch (782:7): [True: 0, False: 59] ------------------ 783| 0| { 784| 0| g_warning ("cannot derive type '%s' from invalid parent type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 785| 0| type_name, 786| 0| type_descriptive_name_I (parent_type)); 787| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 788| 0| } 789| 59| finfo = type_node_fundamental_info_I (pnode); 790| | /* ensure flat derivability */ 791| 59| if (!(finfo->type_flags & G_TYPE_FLAG_DERIVABLE)) ------------------ | Branch (791:7): [True: 0, False: 59] ------------------ 792| 0| { 793| 0| g_warning ("cannot derive '%s' from non-derivable parent type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 794| 0| type_name, 795| 0| NODE_NAME (pnode)); 796| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 797| 0| } 798| | /* ensure deep derivability */ 799| 59| if (parent_type != NODE_FUNDAMENTAL_TYPE (pnode) && ------------------ | | 254| 118|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ | Branch (799:7): [True: 2, False: 57] ------------------ 800| 2| !(finfo->type_flags & G_TYPE_FLAG_DEEP_DERIVABLE)) ------------------ | Branch (800:7): [True: 0, False: 2] ------------------ 801| 0| { 802| 0| g_warning ("cannot derive '%s' from non-fundamental parent type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 803| 0| type_name, 804| 0| NODE_NAME (pnode)); 805| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 806| 0| } 807| | 808| 59| return TRUE; ------------------ | | 818| 59|#define TRUE (!FALSE) | | ------------------ | | | | 814| 59|#define FALSE (0) | | ------------------ ------------------ 809| 59|} gtype.c:type_data_ref_Wm: 1227| 59|{ 1228| 59| if (!node->data) ------------------ | Branch (1228:7): [True: 0, False: 59] ------------------ 1229| 0| { 1230| 0| TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 0|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 1231| 0| GTypeInfo tmp_info; 1232| 0| GTypeValueTable tmp_value_table; 1233| | 1234| 0| g_assert (node->plugin != NULL); ------------------ | | 231| 0|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 232| 0| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 233| 0| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1235| | 1236| 0| if (pnode) ------------------ | Branch (1236:11): [True: 0, False: 0] ------------------ 1237| 0| { 1238| 0| type_data_ref_Wm (pnode); 1239| 0| if (node->data) ------------------ | Branch (1239:8): [True: 0, False: 0] ------------------ 1240| 0| INVALID_RECURSION ("g_type_plugin_*", node->plugin, NODE_NAME (node)); ------------------ | | 131| 0|#define INVALID_RECURSION(func, arg, type_name) G_STMT_START{ \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 132| 0| static const gchar _action[] = " invalidly modified type "; \ | | 133| 0| gpointer _arg = (gpointer) (arg); const gchar *_tname = (type_name), *_fname = (func); \ | | 134| 0| if (_arg) \ | | ------------------ | | | Branch (134:9): [True: 0, False: 0] | | ------------------ | | 135| 0| g_error ("%s(%p)%s'%s'", _fname, _arg, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 136| 0| else \ | | 137| 0| g_error ("%s()%s'%s'", _fname, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 138| 0|}G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1241| 0| } 1242| | 1243| 0| memset (&tmp_info, 0, sizeof (tmp_info)); 1244| 0| memset (&tmp_value_table, 0, sizeof (tmp_value_table)); 1245| | 1246| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 1247| 0| g_type_plugin_use (node->plugin); 1248| 0| g_type_plugin_complete_type_info (node->plugin, NODE_TYPE (node), &tmp_info, &tmp_value_table); ------------------ | | 252| 0|#define NODE_TYPE(node) (node->supers[0]) ------------------ 1249| 0| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 0|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 1250| 0| if (node->data) ------------------ | Branch (1250:11): [True: 0, False: 0] ------------------ 1251| 0| INVALID_RECURSION ("g_type_plugin_*", node->plugin, NODE_NAME (node)); ------------------ | | 131| 0|#define INVALID_RECURSION(func, arg, type_name) G_STMT_START{ \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 132| 0| static const gchar _action[] = " invalidly modified type "; \ | | 133| 0| gpointer _arg = (gpointer) (arg); const gchar *_tname = (type_name), *_fname = (func); \ | | 134| 0| if (_arg) \ | | ------------------ | | | Branch (134:9): [True: 0, False: 0] | | ------------------ | | 135| 0| g_error ("%s(%p)%s'%s'", _fname, _arg, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 136| 0| else \ | | 137| 0| g_error ("%s()%s'%s'", _fname, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 138| 0|}G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1252| | 1253| 0| check_type_info_I (pnode, NODE_FUNDAMENTAL_TYPE (node), NODE_NAME (node), &tmp_info); ------------------ | | 254| 0|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ check_type_info_I (pnode, NODE_FUNDAMENTAL_TYPE (node), NODE_NAME (node), &tmp_info); ------------------ | | 255| 0|#define NODE_NAME(node) (g_quark_to_string (node->qname)) ------------------ 1254| 0| type_data_make_W (node, &tmp_info, 1255| 0| check_value_table_I (NODE_NAME (node), ------------------ | | 255| 0|#define NODE_NAME(node) (g_quark_to_string (node->qname)) ------------------ | Branch (1255:4): [True: 0, False: 0] ------------------ 1256| 0| &tmp_value_table) ? &tmp_value_table : NULL); 1257| 0| } 1258| 59| else 1259| 59| { 1260| 59| g_assert (NODE_REFCOUNT (node) > 0); ------------------ | | 231| 59|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 59|#define G_STMT_START do | | ------------------ | | 232| 59| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | 1018| 177| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [Folded, False: 59] | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | ------------------ | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | 1020| 59| else \ | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | 1023| 59|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 59, False: 0] | | | | ------------------ | | ------------------ | | 233| 59| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 59| } G_STMT_END | | ------------------ | | | | 882| 59|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 59] | | | | ------------------ | | ------------------ ------------------ 1261| | 1262| 59| g_atomic_int_inc ((int *) &node->ref_count); ------------------ | | 148| 59| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 149| 59| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 59|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 150| 59| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (150:13): [Folded, False: 59] | | ------------------ | | 151| 59| (void) __atomic_fetch_add ((atomic), 1, __ATOMIC_SEQ_CST); \ | | 152| 59| })) ------------------ 1263| 59| } 1264| 59|} gtype.c:type_node_new_W: 567| 59|{ 568| 59| g_assert (pnode); ------------------ | | 231| 59|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 59|#define G_STMT_START do | | ------------------ | | 232| 59| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | 1018| 59| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | ------------------ | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | 1020| 59| else \ | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | 1023| 59|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 59, False: 0] | | | | ------------------ | | ------------------ | | 233| 59| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 59| } G_STMT_END | | ------------------ | | | | 882| 59|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 59] | | | | ------------------ | | ------------------ ------------------ 569| 59| g_assert (pnode->n_supers < MAX_N_SUPERS); ------------------ | | 231| 59|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 59|#define G_STMT_START do | | ------------------ | | 232| 59| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | 1018| 59| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | ------------------ | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | 1020| 59| else \ | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | 1023| 59|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 59, False: 0] | | | | ------------------ | | ------------------ | | 233| 59| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 59| } G_STMT_END | | ------------------ | | | | 882| 59|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 59] | | | | ------------------ | | ------------------ ------------------ 570| 59| g_assert (pnode->n_children < MAX_N_CHILDREN); ------------------ | | 231| 59|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 59|#define G_STMT_START do | | ------------------ | | 232| 59| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 59|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 59| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 59|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 59| int _g_boolean_var_; \ | | | | | | 1018| 59| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 59, False: 0] | | | | | | ------------------ | | | | | | 1019| 59| _g_boolean_var_ = 1; \ | | | | | | 1020| 59| else \ | | | | | | 1021| 59| _g_boolean_var_ = 0; \ | | | | | | 1022| 59| _g_boolean_var_; \ | | | | | | 1023| 59|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 59, False: 0] | | | | ------------------ | | ------------------ | | 233| 59| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 59| } G_STMT_END | | ------------------ | | | | 882| 59|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 59] | | | | ------------------ | | ------------------ ------------------ 571| | 572| 59| return type_node_any_new_W (pnode, NODE_FUNDAMENTAL_TYPE (pnode), name, plugin, 0); ------------------ | | 254| 59|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ 573| 59|} gtype.c:check_add_interface_L: 991| 3|{ 992| 3| TypeNode *node = lookup_type_node_I (instance_type); 993| 3| TypeNode *iface = lookup_type_node_I (iface_type); 994| 3| IFaceEntry *entry; 995| 3| TypeNode *tnode; 996| 3| GType *prerequisites; 997| 3| guint i; 998| | 999| | 1000| 3| if (!node || !node->is_instantiatable) ------------------ | Branch (1000:7): [True: 0, False: 3] | Branch (1000:16): [True: 0, False: 3] ------------------ 1001| 0| { 1002| 0| g_warning ("cannot add interfaces to invalid (non-instantiatable) type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1003| 0| type_descriptive_name_I (instance_type)); 1004| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1005| 0| } 1006| 3| if (!iface || !NODE_IS_IFACE (iface)) ------------------ | | 258| 3|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 3|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 3|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 3|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 3|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1006:7): [True: 0, False: 3] | Branch (1006:17): [True: 0, False: 3] ------------------ 1007| 0| { 1008| 0| g_warning ("cannot add invalid (non-interface) type '%s' to type '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1009| 0| type_descriptive_name_I (iface_type), 1010| 0| NODE_NAME (node)); 1011| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1012| 0| } 1013| 3| if (node->data && node->data->class.class) ------------------ | Branch (1013:7): [True: 3, False: 0] | Branch (1013:21): [True: 0, False: 3] ------------------ 1014| 0| { 1015| 0| g_warning ("attempting to add an interface (%s) to class (%s) after class_init", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1016| 0| NODE_NAME (iface), NODE_NAME (node)); 1017| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1018| 0| } 1019| 3| tnode = lookup_type_node_I (NODE_PARENT_TYPE (iface)); ------------------ | | 253| 3|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 1020| 3| if (NODE_PARENT_TYPE (tnode) && !type_lookup_iface_entry_L (node, tnode)) ------------------ | | 253| 6|#define NODE_PARENT_TYPE(node) (node->supers[1]) | | ------------------ | | | Branch (253:34): [True: 0, False: 3] | | ------------------ ------------------ | Branch (1020:35): [True: 0, False: 0] ------------------ 1021| 0| { 1022| | /* 2001/7/31:timj: erk, i guess this warning is junk as interface derivation is flat */ 1023| 0| g_warning ("cannot add sub-interface '%s' to type '%s' which does not conform to super-interface '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1024| 0| NODE_NAME (iface), 1025| 0| NODE_NAME (node), 1026| 0| NODE_NAME (tnode)); 1027| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1028| 0| } 1029| | /* allow overriding of interface type introduced for parent type */ 1030| 3| entry = type_lookup_iface_entry_L (node, iface); 1031| 3| if (entry && entry->vtable == NULL && !type_iface_peek_holder_L (iface, NODE_TYPE (node))) ------------------ | | 252| 0|#define NODE_TYPE(node) (node->supers[0]) ------------------ | Branch (1031:7): [True: 0, False: 3] | Branch (1031:16): [True: 0, False: 0] | Branch (1031:41): [True: 0, False: 0] ------------------ 1032| 0| { 1033| | /* ok, we do conform to this interface already, but the interface vtable was not 1034| | * yet initialized, and we just conform to the interface because it got added to 1035| | * one of our parents. so we allow overriding of holder info here. 1036| | */ 1037| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 1038| 0| } 1039| | /* check whether one of our children already conforms (or whether the interface 1040| | * got added to this node already) 1041| | */ 1042| 3| tnode = find_conforming_child_type_L (node, iface); /* tnode is_a node */ 1043| 3| if (tnode) ------------------ | Branch (1043:7): [True: 0, False: 3] ------------------ 1044| 0| { 1045| 0| g_warning ("cannot add interface type '%s' to type '%s', since type '%s' already conforms to interface", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1046| 0| NODE_NAME (iface), 1047| 0| NODE_NAME (node), 1048| 0| NODE_NAME (tnode)); 1049| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1050| 0| } 1051| 3| prerequisites = IFACE_NODE_PREREQUISITES (iface); ------------------ | | 262| 3|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 1052| 7| for (i = 0; i < IFACE_NODE_N_PREREQUISITES (iface); i++) ------------------ | | 261| 7|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ | Branch (1052:15): [True: 4, False: 3] ------------------ 1053| 4| { 1054| 4| tnode = lookup_type_node_I (prerequisites[i]); 1055| 4| if (!type_node_is_a_L (node, tnode)) ------------------ | Branch (1055:11): [True: 0, False: 4] ------------------ 1056| 0| { 1057| 0| g_warning ("cannot add interface type '%s' to type '%s' which does not conform to prerequisite '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1058| 0| NODE_NAME (iface), 1059| 0| NODE_NAME (node), 1060| 0| NODE_NAME (tnode)); 1061| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1062| 0| } 1063| 4| } 1064| 3| return TRUE; ------------------ | | 818| 3|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3|#define FALSE (0) | | ------------------ ------------------ 1065| 3|} gtype.c:type_lookup_iface_entry_L: 619| 18|{ 620| 18| if (!NODE_IS_IFACE (iface_node)) ------------------ | | 258| 18|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 18|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 18|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 18|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 18|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (620:7): [True: 0, False: 18] ------------------ 621| 0| return NULL; 622| | 623| 18| return lookup_iface_entry_I (CLASSED_NODE_IFACES_ENTRIES_LOCKED (node), ------------------ | | 260| 18|#define CLASSED_NODE_IFACES_ENTRIES_LOCKED(node)(G_ATOMIC_ARRAY_GET_LOCKED(CLASSED_NODE_IFACES_ENTRIES((node)), IFaceEntries)) | | ------------------ | | | | 42| 18|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) | | ------------------ ------------------ 624| 18| iface_node); 625| 18|} gtype.c:lookup_iface_entry_I: 578| 444k|{ 579| 444k| guint8 *offsets; 580| 444k| gsize offset_index; 581| 444k| IFaceEntry *check; 582| 444k| gsize index; 583| 444k| IFaceEntry *entry; 584| | 585| 444k| if (entries == NULL) ------------------ | Branch (585:7): [True: 10, False: 444k] ------------------ 586| 10| return NULL; 587| | 588| 444k| G_ATOMIC_ARRAY_DO_TRANSACTION ------------------ | | 44| 444k|#define G_ATOMIC_ARRAY_DO_TRANSACTION(_array, _type, _C_) G_STMT_START { \ | | ------------------ | | | | 874| 444k|#define G_STMT_START do | | ------------------ | | 45| 444k| gpointer *_datap = &(_array)->data; \ | | 46| 444k| _type *transaction_data, *__check; \ | | 47| 444k| \ | | 48| 444k| __check = g_atomic_pointer_get (_datap); \ | | ------------------ | | | | 113| 444k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 444k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 444k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 444k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 444k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 444k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 444k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 444k| gapg_temp_newval; \ | | | | 119| 444k| })) | | ------------------ | | 49| 444k| do { \ | | 50| 444k| transaction_data = __check; \ | | 51| 4.44M| {_C_;} \ | | ------------------ | | | Branch (51:8): [True: 444k, False: 2] | | | Branch (51:8): [True: 444k, False: 0] | | | Branch (51:8): [True: 444k, False: 0] | | | Branch (51:8): [True: 444k, False: 0] | | | Branch (51:8): [True: 444k, False: 0] | | ------------------ | | 52| 444k| __check = g_atomic_pointer_get (_datap); \ | | ------------------ | | | | 113| 444k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 444k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 444k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 444k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 444k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 444k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 444k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 444k| gapg_temp_newval; \ | | | | 119| 444k| })) | | ------------------ | | 53| 444k| } while (transaction_data != __check); \ | | ------------------ | | | Branch (53:14): [True: 0, False: 444k] | | ------------------ | | 54| 444k| } G_STMT_END | | ------------------ | | | | 882| 444k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 444k] | | | | ------------------ | | ------------------ ------------------ 589| 444k| (&iface_node->_prot.offsets, guint8, 590| | 591| 444k| entry = NULL; 592| 444k| offsets = transaction_data; 593| 444k| offset_index = entries->offset_index; 594| 444k| if (offsets != NULL && 595| 444k| offset_index < G_ATOMIC_ARRAY_DATA_SIZE(offsets)) 596| 444k| { 597| 444k| index = offsets[offset_index]; 598| 444k| if (index > 0) 599| 444k| { 600| | /* zero means unset, subtract one to get real index */ 601| 444k| index -= 1; 602| | 603| 444k| if (index < IFACE_ENTRIES_N_ENTRIES (entries)) 604| 444k| { 605| 444k| check = (IFaceEntry *)&entries->entry[index]; 606| 444k| if (check->iface_type == NODE_TYPE (iface_node)) 607| 444k| entry = check; 608| 444k| } 609| 444k| } 610| 444k| } 611| 444k| ); 612| | 613| 444k| return entry; 614| 444k|} gtype.c:type_iface_peek_holder_L: 1750| 7|{ 1751| 7| IFaceHolder *iholder; 1752| | 1753| 7| g_assert (NODE_IS_IFACE (iface)); ------------------ | | 231| 7|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 7|#define G_STMT_START do | | ------------------ | | 232| 7| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 7|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7| int _g_boolean_var_; \ | | | | | | 1018| 7| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | ------------------ | | | | | | 1019| 7| _g_boolean_var_ = 1; \ | | | | | | 1020| 7| else \ | | | | | | 1021| 7| _g_boolean_var_ = 0; \ | | | | | | 1022| 7| _g_boolean_var_; \ | | | | | | 1023| 7|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 233| 7| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 7| } G_STMT_END | | ------------------ | | | | 882| 7|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7] | | | | ------------------ | | ------------------ ------------------ 1754| | 1755| 7| iholder = iface_node_get_holders_L (iface); ------------------ | | 263| 7|#define iface_node_get_holders_L(node) ((IFaceHolder*) type_get_qdata_L ((node), static_quark_iface_holder)) ------------------ 1756| 8| while (iholder && iholder->instance_type != instance_type) ------------------ | Branch (1756:10): [True: 7, False: 1] | Branch (1756:21): [True: 1, False: 6] ------------------ 1757| 1| iholder = iholder->next; 1758| 7| return iholder; 1759| 7|} gtype.c:find_conforming_child_type_L: 975| 3|{ 976| 3| TypeNode *node = NULL; 977| 3| guint i; 978| | 979| 3| if (type_lookup_iface_entry_L (pnode, iface)) ------------------ | Branch (979:7): [True: 0, False: 3] ------------------ 980| 0| return pnode; 981| | 982| 3| for (i = 0; i < pnode->n_children && !node; i++) ------------------ | Branch (982:15): [True: 0, False: 3] | Branch (982:40): [True: 0, False: 0] ------------------ 983| 0| node = find_conforming_child_type_L (lookup_type_node_I (pnode->children[i]), iface); 984| | 985| 3| return node; 986| 3|} gtype.c:check_interface_info_I: 1071| 3|{ 1072| 3| if ((info->interface_finalize || info->interface_data) && !info->interface_init) ------------------ | Branch (1072:8): [True: 0, False: 3] | Branch (1072:36): [True: 0, False: 3] | Branch (1072:61): [True: 0, False: 0] ------------------ 1073| 0| { 1074| 0| g_warning ("interface type '%s' for type '%s' comes without initializer", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 1075| 0| NODE_NAME (iface), 1076| 0| type_descriptive_name_I (instance_type)); 1077| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1078| 0| } 1079| | 1080| 3| return TRUE; ------------------ | | 818| 3|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3|#define FALSE (0) | | ------------------ ------------------ 1081| 3|} gtype.c:type_add_interface_Wm: 1469| 3|{ 1470| 3| IFaceHolder *iholder = g_new0 (IFaceHolder, 1); ------------------ | | 307| 3|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 3| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 3| gsize __n = (gsize) (n_structs); \ | | | | 237| 3| gsize __s = sizeof (struct_type); \ | | | | 238| 3| gpointer __p; \ | | | | 239| 3| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 3] | | | | ------------------ | | | | 240| 3| __p = g_##func (__n); \ | | | | 241| 3| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 3, False: 0] | | | | ------------------ | | | | 242| 3| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 3|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 3|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 3] | | | | | Branch (242:26): [True: 3, False: 0] | | | | ------------------ | | | | 243| 3| __p = g_##func (__n * __s); \ | | | | 244| 3| else \ | | | | 245| 3| __p = g_##func##_n (__n, __s); \ | | | | 246| 3| __p; \ | | | | 247| 3| })) | | ------------------ ------------------ 1471| 3| IFaceEntry *entry; 1472| 3| guint i; 1473| | 1474| 3| g_assert (node->is_instantiatable && NODE_IS_IFACE (iface) && ((info && !plugin) || (!info && plugin))); ------------------ | | 231| 3|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 232| 3| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 24| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 233| 3| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1475| | 1476| 3| iholder->next = iface_node_get_holders_L (iface); ------------------ | | 263| 3|#define iface_node_get_holders_L(node) ((IFaceHolder*) type_get_qdata_L ((node), static_quark_iface_holder)) ------------------ 1477| 3| iface_node_set_holders_W (iface, iholder); ------------------ | | 264| 3|#define iface_node_set_holders_W(node, holders) (type_set_qdata_W ((node), static_quark_iface_holder, (holders))) ------------------ 1478| 3| iholder->instance_type = NODE_TYPE (node); ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ 1479| 3| iholder->info = info ? g_memdup2 (info, sizeof (*info)) : NULL; ------------------ | Branch (1479:19): [True: 3, False: 0] ------------------ 1480| 3| iholder->plugin = plugin; 1481| | 1482| | /* create an iface entry for this type */ 1483| 3| type_node_add_iface_entry_W (node, NODE_TYPE (iface), NULL); ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ 1484| | 1485| | /* if the class is already (partly) initialized, we may need to base 1486| | * initialize and/or initialize the new interface. 1487| | */ 1488| 3| if (node->data) ------------------ | Branch (1488:7): [True: 3, False: 0] ------------------ 1489| 3| { 1490| 3| InitState class_state = g_atomic_int_get (&node->data->class.init_state); ------------------ | | 96| 3| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 3| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 3|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 3| gint gaig_temp; \ | | 99| 3| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 3] | | ------------------ | | 100| 3| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 3| (gint) gaig_temp; \ | | 102| 3| })) ------------------ 1491| | 1492| 3| if (class_state >= BASE_IFACE_INIT) ------------------ | Branch (1492:11): [True: 0, False: 3] ------------------ 1493| 0| type_iface_vtable_base_init_Wm (iface, node); 1494| | 1495| 3| if (class_state >= IFACE_INIT) ------------------ | Branch (1495:11): [True: 0, False: 3] ------------------ 1496| 0| type_iface_vtable_iface_init_Wm (iface, node); 1497| 3| } 1498| | 1499| | /* create iface entries for children of this type */ 1500| 3| entry = type_lookup_iface_entry_L (node, iface); 1501| 3| for (i = 0; i < node->n_children; i++) ------------------ | Branch (1501:15): [True: 0, False: 3] ------------------ 1502| 0| type_node_add_iface_entry_W (lookup_type_node_I (node->children[i]), NODE_TYPE (iface), entry); ------------------ | | 252| 0|#define NODE_TYPE(node) (node->supers[0]) ------------------ 1503| 3|} gtype.c:type_node_add_iface_entry_W: 1369| 3|{ 1370| 3| IFaceEntries *entries; 1371| 3| IFaceEntry *entry; 1372| 3| TypeNode *iface_node; 1373| 3| guint i, j; 1374| 3| guint num_entries; 1375| | 1376| 3| g_assert (node->is_instantiatable); ------------------ | | 231| 3|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 232| 3| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 233| 3| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 1377| | 1378| 3| entries = CLASSED_NODE_IFACES_ENTRIES_LOCKED (node); ------------------ | | 260| 3|#define CLASSED_NODE_IFACES_ENTRIES_LOCKED(node)(G_ATOMIC_ARRAY_GET_LOCKED(CLASSED_NODE_IFACES_ENTRIES((node)), IFaceEntries)) | | ------------------ | | | | 42| 3|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) | | ------------------ ------------------ 1379| 3| if (entries != NULL) ------------------ | Branch (1379:7): [True: 1, False: 2] ------------------ 1380| 1| { 1381| 1| num_entries = IFACE_ENTRIES_N_ENTRIES (entries); ------------------ | | 294| 1|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 1|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 1|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ 1382| | 1383| 1| g_assert (num_entries < MAX_N_INTERFACES); ------------------ | | 231| 1|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 232| 1| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 233| 1| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1384| | 1385| 2| for (i = 0; i < num_entries; i++) ------------------ | Branch (1385:19): [True: 1, False: 1] ------------------ 1386| 1| { 1387| 1| entry = &entries->entry[i]; 1388| 1| if (entry->iface_type == iface_type) ------------------ | Branch (1388:8): [True: 0, False: 1] ------------------ 1389| 0| { 1390| | /* this can happen in two cases: 1391| | * - our parent type already conformed to iface_type and node 1392| | * got its own holder info. here, our children already have 1393| | * entries and NULL vtables, since this will only work for 1394| | * uninitialized classes. 1395| | * - an interface type is added to an ancestor after it was 1396| | * added to a child type. 1397| | */ 1398| 0| if (!parent_entry) ------------------ | Branch (1398:12): [True: 0, False: 0] ------------------ 1399| 0| g_assert (entry->vtable == NULL && entry->init_state == UNINITIALIZED); ------------------ | | 231| 0|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 232| 0| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 233| 0| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1400| 0| else 1401| 0| { 1402| | /* sick, interface is added to ancestor *after* child type; 1403| | * nothing todo, the entry and our children were already setup correctly 1404| | */ 1405| 0| } 1406| 0| return; 1407| 0| } 1408| 1| } 1409| 1| } 1410| | 1411| 3| entries = _g_atomic_array_copy (CLASSED_NODE_IFACES_ENTRIES (node), ------------------ | | 259| 3|#define CLASSED_NODE_IFACES_ENTRIES(node) (&(node)->_prot.iface_entries) ------------------ 1412| 3| IFACE_ENTRIES_HEADER_SIZE, ------------------ | | 293| 3|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) ------------------ 1413| 3| sizeof (IFaceEntry)); 1414| 3| num_entries = IFACE_ENTRIES_N_ENTRIES (entries); ------------------ | | 294| 3|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 3|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 3|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ 1415| 3| i = num_entries - 1; 1416| 3| if (i == 0) ------------------ | Branch (1416:7): [True: 2, False: 1] ------------------ 1417| 2| entries->offset_index = 0; 1418| 3| entries->entry[i].iface_type = iface_type; 1419| 3| entries->entry[i].vtable = NULL; 1420| 3| entries->entry[i].init_state = UNINITIALIZED; 1421| | 1422| 3| if (parent_entry) ------------------ | Branch (1422:7): [True: 0, False: 3] ------------------ 1423| 0| { 1424| 0| if (node->data && g_atomic_int_get (&node->data->class.init_state) >= BASE_IFACE_INIT) ------------------ | | 96| 0| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 97| 0| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 0|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 98| 0| gint gaig_temp; \ | | 99| 0| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | ------------------ | | | Branch (99:13): [Folded, False: 0] | | ------------------ | | 100| 0| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | 101| 0| (gint) gaig_temp; \ | | 102| 0| })) ------------------ | Branch (1424:11): [True: 0, False: 0] | Branch (1424:25): [True: 0, False: 0] ------------------ 1425| 0| { 1426| 0| entries->entry[i].init_state = INITIALIZED; 1427| 0| entries->entry[i].vtable = parent_entry->vtable; 1428| 0| } 1429| 0| } 1430| | 1431| | /* Update offsets in iface */ 1432| 3| iface_node = lookup_type_node_I (iface_type); 1433| | 1434| 3| if (iface_node_has_available_offset_L (iface_node, ------------------ | Branch (1434:7): [True: 3, False: 0] ------------------ 1435| 3| entries->offset_index, 1436| 3| i)) 1437| 3| { 1438| 3| iface_node_set_offset_L (iface_node, 1439| 3| entries->offset_index, i); 1440| 3| } 1441| 0| else 1442| 0| { 1443| 0| entries->offset_index = 1444| 0| find_free_iface_offset_L (entries); 1445| 0| for (j = 0; j < IFACE_ENTRIES_N_ENTRIES (entries); j++) ------------------ | | 294| 0|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 0|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 0|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (1445:19): [True: 0, False: 0] ------------------ 1446| 0| { 1447| 0| entry = &entries->entry[j]; 1448| 0| iface_node = 1449| 0| lookup_type_node_I (entry->iface_type); 1450| 0| iface_node_set_offset_L (iface_node, 1451| 0| entries->offset_index, j); 1452| 0| } 1453| 0| } 1454| | 1455| 3| _g_atomic_array_update (CLASSED_NODE_IFACES_ENTRIES (node), entries); ------------------ | | 259| 3|#define CLASSED_NODE_IFACES_ENTRIES(node) (&(node)->_prot.iface_entries) ------------------ 1456| | 1457| 3| if (parent_entry) ------------------ | Branch (1457:7): [True: 0, False: 3] ------------------ 1458| 0| { 1459| 0| for (i = 0; i < node->n_children; i++) ------------------ | Branch (1459:19): [True: 0, False: 0] ------------------ 1460| 0| type_node_add_iface_entry_W (lookup_type_node_I (node->children[i]), iface_type, &entries->entry[i]); 1461| 0| } 1462| 3|} gtype.c:iface_node_has_available_offset_L: 1285| 3|{ 1286| 3| guint8 *offsets; 1287| | 1288| 3| offsets = G_ATOMIC_ARRAY_GET_LOCKED (&iface_node->_prot.offsets, guint8); ------------------ | | 42| 3|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) ------------------ 1289| 3| if (offsets == NULL) ------------------ | Branch (1289:7): [True: 3, False: 0] ------------------ 1290| 3| return TRUE; ------------------ | | 818| 3|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3|#define FALSE (0) | | ------------------ ------------------ 1291| | 1292| 0| if (G_ATOMIC_ARRAY_DATA_SIZE (offsets) <= offset) ------------------ | | 28| 0|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) ------------------ | Branch (1292:7): [True: 0, False: 0] ------------------ 1293| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 1294| | 1295| 0| if (offsets[offset] == 0 || ------------------ | Branch (1295:7): [True: 0, False: 0] ------------------ 1296| 0| offsets[offset] == for_index+1) ------------------ | Branch (1296:7): [True: 0, False: 0] ------------------ 1297| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 1298| | 1299| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1300| 0|} gtype.c:iface_node_set_offset_L: 1336| 3|{ 1337| 3| guint8 *offsets, *old_offsets; 1338| 3| gsize new_size, old_size; 1339| 3| gsize i; 1340| | 1341| 3| old_offsets = G_ATOMIC_ARRAY_GET_LOCKED (&iface_node->_prot.offsets, guint8); ------------------ | | 42| 3|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) ------------------ 1342| 3| if (old_offsets == NULL) ------------------ | Branch (1342:7): [True: 3, False: 0] ------------------ 1343| 3| old_size = 0; 1344| 0| else 1345| 0| { 1346| 0| old_size = G_ATOMIC_ARRAY_DATA_SIZE (old_offsets); ------------------ | | 28| 0|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) ------------------ 1347| 0| if (offset < old_size && ------------------ | Branch (1347:11): [True: 0, False: 0] ------------------ 1348| 0| old_offsets[offset] == index + 1) ------------------ | Branch (1348:4): [True: 0, False: 0] ------------------ 1349| 0| return; /* Already set to this index, return */ 1350| 0| } 1351| 3| new_size = MAX (old_size, offset + 1); ------------------ | | 822| 3|#define MAX(a, b) (((a) > (b)) ? (a) : (b)) | | ------------------ | | | Branch (822:21): [True: 0, False: 3] | | ------------------ ------------------ 1352| | 1353| 3| offsets = _g_atomic_array_copy (&iface_node->_prot.offsets, 1354| 3| 0, new_size - old_size); 1355| | 1356| | /* Mark new area as unused */ 1357| 6| for (i = old_size; i < new_size; i++) ------------------ | Branch (1357:22): [True: 3, False: 3] ------------------ 1358| 3| offsets[i] = 0; 1359| | 1360| 3| offsets[offset] = index + 1; 1361| | 1362| 3| _g_atomic_array_update (&iface_node->_prot.offsets, offsets); 1363| 3|} gtype.c:type_iface_vtable_base_init_Wm: 2048| 4|{ 2049| 4| IFaceEntry *entry; 2050| 4| IFaceHolder *iholder; 2051| 4| GTypeInterface *vtable = NULL; 2052| 4| TypeNode *pnode; 2053| | 2054| | /* type_iface_retrieve_holder_info_Wm() doesn't modify write lock for returning NULL */ 2055| 4| iholder = type_iface_retrieve_holder_info_Wm (iface, NODE_TYPE (node), TRUE); ------------------ | | 252| 4|#define NODE_TYPE(node) (node->supers[0]) ------------------ iholder = type_iface_retrieve_holder_info_Wm (iface, NODE_TYPE (node), TRUE); ------------------ | | 818| 4|#define TRUE (!FALSE) | | ------------------ | | | | 814| 4|#define FALSE (0) | | ------------------ ------------------ 2056| 4| if (!iholder) ------------------ | Branch (2056:7): [True: 1, False: 3] ------------------ 2057| 1| return FALSE; /* we don't modify write lock upon FALSE */ ------------------ | | 814| 1|#define FALSE (0) ------------------ 2058| | 2059| 3| type_iface_ensure_dflt_vtable_Wm (iface); 2060| | 2061| 3| entry = type_lookup_iface_entry_L (node, iface); 2062| | 2063| 3| g_assert (iface->data && entry && entry->vtable == NULL && iholder && iholder->info); ------------------ | | 231| 3|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 232| 3| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 27| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 233| 3| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2064| | 2065| 3| entry->init_state = IFACE_INIT; 2066| | 2067| 3| pnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 3|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 2068| 3| if (pnode) /* want to copy over parent iface contents */ ------------------ | Branch (2068:7): [True: 3, False: 0] ------------------ 2069| 3| { 2070| 3| IFaceEntry *pentry = type_lookup_iface_entry_L (pnode, iface); 2071| | 2072| 3| if (pentry) ------------------ | Branch (2072:11): [True: 0, False: 3] ------------------ 2073| 0| vtable = g_memdup2 (pentry->vtable, iface->data->iface.vtable_size); 2074| 3| } 2075| 3| if (!vtable) ------------------ | Branch (2075:7): [True: 3, False: 0] ------------------ 2076| 3| vtable = g_memdup2 (iface->data->iface.dflt_vtable, iface->data->iface.vtable_size); 2077| 3| entry->vtable = vtable; 2078| 3| vtable->g_type = NODE_TYPE (iface); ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ 2079| 3| vtable->g_instance_type = NODE_TYPE (node); ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ 2080| | 2081| 3| if (iface->data->iface.vtable_init_base) ------------------ | Branch (2081:7): [True: 0, False: 3] ------------------ 2082| 0| { 2083| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2084| 0| iface->data->iface.vtable_init_base (vtable); 2085| 0| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 0|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2086| 0| } 2087| 3| return TRUE; /* initialized the vtable */ ------------------ | | 818| 3|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3|#define FALSE (0) | | ------------------ ------------------ 2088| 3|} gtype.c:type_iface_retrieve_holder_info_Wm: 1765| 4|{ 1766| 4| IFaceHolder *iholder = type_iface_peek_holder_L (iface, instance_type); 1767| | 1768| 4| if (iholder && !iholder->info && need_info) ------------------ | Branch (1768:7): [True: 3, False: 1] | Branch (1768:18): [True: 0, False: 3] | Branch (1768:36): [True: 0, False: 0] ------------------ 1769| 0| { 1770| 0| GInterfaceInfo tmp_info; 1771| | 1772| 0| g_assert (iholder->plugin != NULL); ------------------ | | 231| 0|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 232| 0| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 233| 0| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1773| | 1774| 0| type_data_ref_Wm (iface); 1775| 0| if (iholder->info) ------------------ | Branch (1775:11): [True: 0, False: 0] ------------------ 1776| 0| INVALID_RECURSION ("g_type_plugin_*", iface->plugin, NODE_NAME (iface)); ------------------ | | 131| 0|#define INVALID_RECURSION(func, arg, type_name) G_STMT_START{ \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 132| 0| static const gchar _action[] = " invalidly modified type "; \ | | 133| 0| gpointer _arg = (gpointer) (arg); const gchar *_tname = (type_name), *_fname = (func); \ | | 134| 0| if (_arg) \ | | ------------------ | | | Branch (134:9): [True: 0, False: 0] | | ------------------ | | 135| 0| g_error ("%s(%p)%s'%s'", _fname, _arg, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 136| 0| else \ | | 137| 0| g_error ("%s()%s'%s'", _fname, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 138| 0|}G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1777| | 1778| 0| memset (&tmp_info, 0, sizeof (tmp_info)); 1779| | 1780| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 1781| 0| g_type_plugin_use (iholder->plugin); 1782| 0| g_type_plugin_complete_interface_info (iholder->plugin, instance_type, NODE_TYPE (iface), &tmp_info); ------------------ | | 252| 0|#define NODE_TYPE(node) (node->supers[0]) ------------------ 1783| 0| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 0|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 1784| 0| if (iholder->info) ------------------ | Branch (1784:11): [True: 0, False: 0] ------------------ 1785| 0| INVALID_RECURSION ("g_type_plugin_*", iholder->plugin, NODE_NAME (iface)); ------------------ | | 131| 0|#define INVALID_RECURSION(func, arg, type_name) G_STMT_START{ \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 132| 0| static const gchar _action[] = " invalidly modified type "; \ | | 133| 0| gpointer _arg = (gpointer) (arg); const gchar *_tname = (type_name), *_fname = (func); \ | | 134| 0| if (_arg) \ | | ------------------ | | | Branch (134:9): [True: 0, False: 0] | | ------------------ | | 135| 0| g_error ("%s(%p)%s'%s'", _fname, _arg, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 136| 0| else \ | | 137| 0| g_error ("%s()%s'%s'", _fname, _action, _tname); \ | | ------------------ | | | | 333| 0|#define g_error(...) G_STMT_START { \ | | | | ------------------ | | | | | | 874| 0|#define G_STMT_START do | | | | ------------------ | | | | 334| 0| g_log (G_LOG_DOMAIN, \ | | | | 335| 0| G_LOG_LEVEL_ERROR, \ | | | | 336| 0| __VA_ARGS__); \ | | | | 337| 0| for (;;) ; \ | | | | 338| 0| } G_STMT_END | | | | ------------------ | | | | | | 882| 0|#define G_STMT_END while (0) | | | | | | ------------------ | | | | | | | Branch (882:30): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 138| 0|}G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1786| | 1787| 0| check_interface_info_I (iface, instance_type, &tmp_info); 1788| 0| iholder->info = g_memdup2 (&tmp_info, sizeof (tmp_info)); 1789| 0| } 1790| | 1791| 4| return iholder; /* we don't modify write lock upon returning NULL */ 1792| 4|} gtype.c:type_iface_vtable_iface_init_Wm: 2099| 3|{ 2100| 3| IFaceEntry *entry = type_lookup_iface_entry_L (node, iface); 2101| 3| IFaceHolder *iholder = type_iface_peek_holder_L (iface, NODE_TYPE (node)); ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ 2102| 3| GTypeInterface *vtable = NULL; 2103| 3| guint i; 2104| | 2105| | /* iholder->info should have been filled in by type_iface_vtable_base_init_Wm() */ 2106| 3| g_assert (iface->data && entry && iholder && iholder->info); ------------------ | | 231| 3|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 232| 3| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 21| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 233| 3| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2107| 3| g_assert (entry->init_state == IFACE_INIT); /* assert prior base_init() */ ------------------ | | 231| 3|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 232| 3| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 233| 3| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2108| | 2109| 3| entry->init_state = INITIALIZED; 2110| | 2111| 3| vtable = entry->vtable; 2112| | 2113| 3| if (iholder->info->interface_init) ------------------ | Branch (2113:7): [True: 3, False: 0] ------------------ 2114| 3| { 2115| 3| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 3|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2116| 3| if (iholder->info->interface_init) ------------------ | Branch (2116:11): [True: 3, False: 0] ------------------ 2117| 3| iholder->info->interface_init (vtable, iholder->info->interface_data); 2118| 3| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 3|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2119| 3| } 2120| | 2121| 6| for (i = 0; i < static_n_iface_check_funcs; i++) ------------------ | Branch (2121:15): [True: 3, False: 3] ------------------ 2122| 3| { 2123| 3| GTypeInterfaceCheckFunc check_func = static_iface_check_funcs[i].check_func; 2124| 3| gpointer check_data = static_iface_check_funcs[i].check_data; 2125| | 2126| 3| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 3|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2127| 3| check_func (check_data, (gpointer)vtable); 2128| 3| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 3|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2129| 3| } 2130| 3|} gtype.c:type_data_ref_U: 1268| 7.71k|{ 1269| 7.71k| guint current; 1270| | 1271| 7.71k| do { 1272| 7.71k| current = NODE_REFCOUNT (node); ------------------ | | 256| 7.71k|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 7.71k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 7.71k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 7.71k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 7.71k| gint gaig_temp; \ | | | | 99| 7.71k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 7.71k] | | | | ------------------ | | | | 100| 7.71k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 7.71k| (gint) gaig_temp; \ | | | | 102| 7.71k| })) | | ------------------ ------------------ 1273| | 1274| 7.71k| if (current < 1) ------------------ | Branch (1274:9): [True: 0, False: 7.71k] ------------------ 1275| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 1276| 7.71k| } while (!g_atomic_int_compare_and_exchange ((int *) &node->ref_count, current, current + 1)); ------------------ | | 160| 7.71k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 161| 7.71k| gint gaicae_oldval = (oldval); \ | | 162| 7.71k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.71k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 163| 7.71k| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | ------------------ | | | Branch (163:13): [Folded, False: 7.71k] | | ------------------ | | 164| 7.71k| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 7.71k|#define FALSE (0) | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 818| 7.71k|#define TRUE (!FALSE) | | | | ------------------ | | | | | | 814| 7.71k|#define FALSE (0) | | | | ------------------ | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (164:5): [True: 7.71k, False: 0] | | ------------------ | | 165| 7.71k| })) ------------------ | Branch (1276:12): [True: 0, False: 7.71k] ------------------ 1277| | 1278| 7.71k| return TRUE; ------------------ | | 818| 7.71k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 7.71k|#define FALSE (0) | | ------------------ ------------------ 1279| 7.71k|} gtype.c:type_class_init_Wm: 2170| 7|{ 2171| 7| GSList *slist, *init_slist = NULL; 2172| 7| GTypeClass *class; 2173| 7| IFaceEntries *entries; 2174| 7| IFaceEntry *entry; 2175| 7| TypeNode *bnode, *pnode; 2176| 7| guint i; 2177| | 2178| | /* Accessing data->class will work for instantiatable types 2179| | * too because ClassData is a subset of InstanceData 2180| | */ 2181| 7| g_assert (node->is_classed && node->data && ------------------ | | 231| 7|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 7|#define G_STMT_START do | | ------------------ | | 232| 7| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 7|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7| int _g_boolean_var_; \ | | | | | | 1018| 77| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | | Branch (1018:8): [Folded, False: 7] | | | | | | | Branch (1018:8): [True: 7, False: 0] | | | | | | ------------------ | | | | | | 1019| 7| _g_boolean_var_ = 1; \ | | | | | | 1020| 7| else \ | | | | | | 1021| 7| _g_boolean_var_ = 0; \ | | | | | | 1022| 7| _g_boolean_var_; \ | | | | | | 1023| 7|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 233| 7| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 7| } G_STMT_END | | ------------------ | | | | 882| 7|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7] | | | | ------------------ | | ------------------ ------------------ 2182| 7| node->data->class.class_size && 2183| 7| !node->data->class.class && 2184| 7| g_atomic_int_get (&node->data->class.init_state) == UNINITIALIZED); 2185| 7| if (node->data->class.class_private_size) ------------------ | Branch (2185:7): [True: 0, False: 7] ------------------ 2186| 0| class = g_malloc0 (ALIGN_STRUCT (node->data->class.class_size) + node->data->class.class_private_size); ------------------ | | 161| 0| ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ | | ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT) | | ------------------ | | | | 159| 0|#define STRUCT_ALIGNMENT (2 * sizeof (gsize)) | | ------------------ ------------------ 2187| 7| else 2188| 7| class = g_malloc0 (node->data->class.class_size); 2189| 7| node->data->class.class = class; 2190| 7| g_atomic_int_set (&node->data->class.init_state, BASE_CLASS_INIT); ------------------ | | 104| 7| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 105| 7| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 106| 7| gint gais_temp = (gint) (newval); \ | | 107| 7| (void) (0 ? *(atomic) ^ (newval) : 1); \ | | ------------------ | | | Branch (107:13): [Folded, False: 7] | | ------------------ | | 108| 7| __atomic_store ((gint *)(atomic), &gais_temp, __ATOMIC_SEQ_CST); \ | | 109| 7| })) ------------------ 2191| | 2192| 7| if (pclass) ------------------ | Branch (2192:7): [True: 5, False: 2] ------------------ 2193| 5| { 2194| 5| TypeNode *pnode = lookup_type_node_I (pclass->g_type); 2195| | 2196| 5| memcpy (class, pclass, pnode->data->class.class_size); 2197| 5| memcpy (G_STRUCT_MEMBER_P (class, ALIGN_STRUCT (node->data->class.class_size)), G_STRUCT_MEMBER_P (pclass, ALIGN_STRUCT (pnode->data->class.class_size)), pnode->data->class.class_private_size); ------------------ | | 860| 5| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ memcpy (G_STRUCT_MEMBER_P (class, ALIGN_STRUCT (node->data->class.class_size)), G_STRUCT_MEMBER_P (pclass, ALIGN_STRUCT (pnode->data->class.class_size)), pnode->data->class.class_private_size); ------------------ | | 860| 5| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 2198| | 2199| 5| if (node->is_instantiatable) ------------------ | Branch (2199:11): [True: 5, False: 0] ------------------ 2200| 5| { 2201| | /* We need to initialize the private_size here rather than in 2202| | * type_data_make_W() since the class init for the parent 2203| | * class may have changed pnode->data->instance.private_size. 2204| | */ 2205| 5| node->data->instance.private_size = pnode->data->instance.private_size; 2206| 5| } 2207| 5| } 2208| 7| class->g_type = NODE_TYPE (node); ------------------ | | 252| 7|#define NODE_TYPE(node) (node->supers[0]) ------------------ 2209| | 2210| 7| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 7|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2211| | 2212| | /* stack all base class initialization functions, so we 2213| | * call them in ascending order. 2214| | */ 2215| 21| for (bnode = node; bnode; bnode = lookup_type_node_I (NODE_PARENT_TYPE (bnode))) ------------------ | | 253| 14|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ | Branch (2215:22): [True: 14, False: 7] ------------------ 2216| 14| if (bnode->data->class.class_init_base) ------------------ | Branch (2216:9): [True: 7, False: 7] ------------------ 2217| 7| init_slist = g_slist_prepend (init_slist, (gpointer) bnode->data->class.class_init_base); 2218| 14| for (slist = init_slist; slist; slist = slist->next) ------------------ | Branch (2218:28): [True: 7, False: 7] ------------------ 2219| 7| { 2220| 7| GBaseInitFunc class_init_base = (GBaseInitFunc) slist->data; 2221| | 2222| 7| class_init_base (class); 2223| 7| } 2224| 7| g_slist_free (init_slist); 2225| | 2226| 7| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 7|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2227| | 2228| 7| g_atomic_int_set (&node->data->class.init_state, BASE_IFACE_INIT); ------------------ | | 104| 7| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 105| 7| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 106| 7| gint gais_temp = (gint) (newval); \ | | 107| 7| (void) (0 ? *(atomic) ^ (newval) : 1); \ | | ------------------ | | | Branch (107:13): [Folded, False: 7] | | ------------------ | | 108| 7| __atomic_store ((gint *)(atomic), &gais_temp, __ATOMIC_SEQ_CST); \ | | 109| 7| })) ------------------ 2229| | 2230| | /* Before we initialize the class, base initialize all interfaces, either 2231| | * from parent, or through our holder info 2232| | */ 2233| 7| pnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); ------------------ | | 253| 7|#define NODE_PARENT_TYPE(node) (node->supers[1]) ------------------ 2234| | 2235| 7| i = 0; 2236| 11| while ((entries = CLASSED_NODE_IFACES_ENTRIES_LOCKED (node)) != NULL && ------------------ | | 260| 11|#define CLASSED_NODE_IFACES_ENTRIES_LOCKED(node)(G_ATOMIC_ARRAY_GET_LOCKED(CLASSED_NODE_IFACES_ENTRIES((node)), IFaceEntries)) | | ------------------ | | | | 42| 11|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) | | ------------------ ------------------ | Branch (2236:10): [True: 7, False: 4] ------------------ 2237| 7| i < IFACE_ENTRIES_N_ENTRIES (entries)) ------------------ | | 294| 7|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 7|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 7|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (2237:4): [True: 4, False: 3] ------------------ 2238| 4| { 2239| 4| entry = &entries->entry[i]; 2240| 4| while (i < IFACE_ENTRIES_N_ENTRIES (entries) && ------------------ | | 294| 8|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 4|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 4|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (2240:14): [True: 4, False: 0] ------------------ 2241| 4| entry->init_state == IFACE_INIT) ------------------ | Branch (2241:7): [True: 0, False: 4] ------------------ 2242| 0| { 2243| 0| entry++; 2244| 0| i++; 2245| 0| } 2246| | 2247| 4| if (i == IFACE_ENTRIES_N_ENTRIES (entries)) ------------------ | | 294| 4|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 4|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 4|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (2247:11): [True: 0, False: 4] ------------------ 2248| 0| break; 2249| | 2250| 4| if (!type_iface_vtable_base_init_Wm (lookup_type_node_I (entry->iface_type), node)) ------------------ | Branch (2250:11): [True: 1, False: 3] ------------------ 2251| 1| { 2252| 1| guint j; 2253| 1| IFaceEntries *pentries = CLASSED_NODE_IFACES_ENTRIES_LOCKED (pnode); ------------------ | | 260| 1|#define CLASSED_NODE_IFACES_ENTRIES_LOCKED(node)(G_ATOMIC_ARRAY_GET_LOCKED(CLASSED_NODE_IFACES_ENTRIES((node)), IFaceEntries)) | | ------------------ | | | | 42| 1|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) | | ------------------ ------------------ 2254| | 2255| | /* need to get this interface from parent, type_iface_vtable_base_init_Wm() 2256| | * doesn't modify write lock upon FALSE, so entry is still valid; 2257| | */ 2258| 1| g_assert (pnode != NULL); ------------------ | | 231| 1|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 232| 1| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 233| 1| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 2259| | 2260| 1| if (pentries) ------------------ | Branch (2260:8): [True: 1, False: 0] ------------------ 2261| 1| for (j = 0; j < IFACE_ENTRIES_N_ENTRIES (pentries); j++) ------------------ | | 294| 1|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 1|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 1|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (2261:18): [True: 1, False: 0] ------------------ 2262| 1| { 2263| 1| IFaceEntry *pentry = &pentries->entry[j]; 2264| | 2265| 1| if (pentry->iface_type == entry->iface_type) ------------------ | Branch (2265:7): [True: 1, False: 0] ------------------ 2266| 1| { 2267| 1| entry->vtable = pentry->vtable; 2268| 1| entry->init_state = INITIALIZED; 2269| 1| break; 2270| 1| } 2271| 1| } 2272| 1| g_assert (entry->vtable != NULL); ------------------ | | 231| 1|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 232| 1| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 233| 1| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 2273| 1| } 2274| | 2275| | /* If the write lock was released, additional interface entries might 2276| | * have been inserted into CLASSED_NODE_IFACES_ENTRIES (node); they'll 2277| | * be base-initialized when inserted, so we don't have to worry that 2278| | * we might miss them. Uninitialized entries can only be moved higher 2279| | * when new ones are inserted. 2280| | */ 2281| 4| i++; 2282| 4| } 2283| | 2284| 7| g_atomic_int_set (&node->data->class.init_state, CLASS_INIT); ------------------ | | 104| 7| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 105| 7| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 106| 7| gint gais_temp = (gint) (newval); \ | | 107| 7| (void) (0 ? *(atomic) ^ (newval) : 1); \ | | ------------------ | | | Branch (107:13): [Folded, False: 7] | | ------------------ | | 108| 7| __atomic_store ((gint *)(atomic), &gais_temp, __ATOMIC_SEQ_CST); \ | | 109| 7| })) ------------------ 2285| | 2286| 7| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 7|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2287| | 2288| 7| if (node->data->class.class_init) ------------------ | Branch (2288:7): [True: 7, False: 0] ------------------ 2289| 7| node->data->class.class_init (class, (gpointer) node->data->class.class_data); 2290| | 2291| 7| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 7|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2292| | 2293| 7| g_atomic_int_set (&node->data->class.init_state, IFACE_INIT); ------------------ | | 104| 7| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 105| 7| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 106| 7| gint gais_temp = (gint) (newval); \ | | 107| 7| (void) (0 ? *(atomic) ^ (newval) : 1); \ | | ------------------ | | | Branch (107:13): [Folded, False: 7] | | ------------------ | | 108| 7| __atomic_store ((gint *)(atomic), &gais_temp, __ATOMIC_SEQ_CST); \ | | 109| 7| })) ------------------ 2294| | 2295| | /* finish initializing the interfaces through our holder info. 2296| | * inherited interfaces are already init_state == INITIALIZED, because 2297| | * they either got setup in the above base_init loop, or during 2298| | * class_init from within type_add_interface_Wm() for this or 2299| | * an ancestor type. 2300| | */ 2301| 7| i = 0; 2302| 10| while ((entries = CLASSED_NODE_IFACES_ENTRIES_LOCKED (node)) != NULL) ------------------ | | 260| 10|#define CLASSED_NODE_IFACES_ENTRIES_LOCKED(node)(G_ATOMIC_ARRAY_GET_LOCKED(CLASSED_NODE_IFACES_ENTRIES((node)), IFaceEntries)) | | ------------------ | | | | 42| 10|#define G_ATOMIC_ARRAY_GET_LOCKED(_array, _type) ((_type *)((_array)->data)) | | ------------------ ------------------ | Branch (2302:10): [True: 6, False: 4] ------------------ 2303| 6| { 2304| 6| entry = &entries->entry[i]; 2305| 7| while (i < IFACE_ENTRIES_N_ENTRIES (entries) && ------------------ | | 294| 14|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 7|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 7|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (2305:14): [True: 4, False: 3] ------------------ 2306| 4| entry->init_state == INITIALIZED) ------------------ | Branch (2306:7): [True: 1, False: 3] ------------------ 2307| 1| { 2308| 1| entry++; 2309| 1| i++; 2310| 1| } 2311| | 2312| 6| if (i == IFACE_ENTRIES_N_ENTRIES (entries)) ------------------ | | 294| 6|#define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 28| 6|#define G_ATOMIC_ARRAY_DATA_SIZE(mem) (*((gsize *) (mem) - 1)) | | ------------------ | | #define IFACE_ENTRIES_N_ENTRIES(_entries) ( (G_ATOMIC_ARRAY_DATA_SIZE((_entries)) - IFACE_ENTRIES_HEADER_SIZE) / sizeof(IFaceEntry) ) | | ------------------ | | | | 293| 6|#define IFACE_ENTRIES_HEADER_SIZE (sizeof(IFaceEntries) - sizeof(IFaceEntry)) | | ------------------ ------------------ | Branch (2312:11): [True: 3, False: 3] ------------------ 2313| 3| break; 2314| | 2315| 3| type_iface_vtable_iface_init_Wm (lookup_type_node_I (entry->iface_type), node); 2316| | 2317| | /* As in the loop above, additional initialized entries might be inserted 2318| | * if the write lock is released, but that's harmless because the entries 2319| | * we need to initialize only move higher in the list. 2320| | */ 2321| 3| i++; 2322| 3| } 2323| | 2324| 7| g_atomic_int_set (&node->data->class.init_state, INITIALIZED); ------------------ | | 104| 7| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 105| 7| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 106| 7| gint gais_temp = (gint) (newval); \ | | 107| 7| (void) (0 ? *(atomic) ^ (newval) : 1); \ | | ------------------ | | | Branch (107:13): [Folded, False: 7] | | ------------------ | | 108| 7| __atomic_store ((gint *)(atomic), &gais_temp, __ATOMIC_SEQ_CST); \ | | 109| 7| })) ------------------ 2325| 7|} gtype.c:type_data_unref_U: 2479| 7.71k|{ 2480| 7.71k| guint current; 2481| | 2482| 7.71k| do { 2483| 7.71k| current = NODE_REFCOUNT (node); ------------------ | | 256| 7.71k|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 7.71k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 7.71k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 7.71k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 7.71k| gint gaig_temp; \ | | | | 99| 7.71k| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 7.71k] | | | | ------------------ | | | | 100| 7.71k| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 7.71k| (gint) gaig_temp; \ | | | | 102| 7.71k| })) | | ------------------ ------------------ 2484| | 2485| 7.71k| if (current <= 1) ------------------ | Branch (2485:9): [True: 0, False: 7.71k] ------------------ 2486| 0| { 2487| 0| if (!node->plugin) ------------------ | Branch (2487:11): [True: 0, False: 0] ------------------ 2488| 0| { 2489| 0| g_warning ("static type '%s' unreferenced too often", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 2490| 0| NODE_NAME (node)); 2491| 0| return; 2492| 0| } 2493| 0| else 2494| 0| { 2495| | /* This is the last reference of a type from a plugin. We are 2496| | * experimentally disabling support for unloading type 2497| | * plugins, so don't allow the last ref to drop. 2498| | */ 2499| 0| return; 2500| 0| } 2501| | 2502| 0| g_assert (current > 0); ------------------ | | 231| 0|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 0|#define G_STMT_START do | | ------------------ | | 232| 0| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 0|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 0| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 0|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 0| int _g_boolean_var_; \ | | | | | | 1018| 0| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 1019| 0| _g_boolean_var_ = 1; \ | | | | | | 1020| 0| else \ | | | | | | 1021| 0| _g_boolean_var_ = 0; \ | | | | | | 1022| 0| _g_boolean_var_; \ | | | | | | 1023| 0|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 233| 0| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 0| } G_STMT_END | | ------------------ | | | | 882| 0|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2503| | 2504| 0| g_rec_mutex_lock (&class_init_rec_mutex); /* required locking order: 1) class_init_rec_mutex, 2) type_rw_lock */ 2505| 0| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 0|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2506| 0| type_data_last_unref_Wm (node, uncached); 2507| 0| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 0|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2508| 0| g_rec_mutex_unlock (&class_init_rec_mutex); 2509| 0| return; 2510| 0| } 2511| 7.71k| } while (!g_atomic_int_compare_and_exchange ((int *) &node->ref_count, current, current - 1)); ------------------ | | 160| 7.71k| (G_GNUC_EXTENSION ({ \ | | ------------------ | | | | 54| 7.71k|#define G_GNUC_EXTENSION __extension__ | | ------------------ | | 161| 7.71k| gint gaicae_oldval = (oldval); \ | | 162| 7.71k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | ------------------ | | | | 765| 7.71k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | ------------------ | | 163| 7.71k| (void) (0 ? *(atomic) ^ (newval) ^ (oldval) : 1); \ | | ------------------ | | | Branch (163:13): [Folded, False: 7.71k] | | ------------------ | | 164| 7.71k| __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 7.71k|#define FALSE (0) | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 818| 7.71k|#define TRUE (!FALSE) | | | | ------------------ | | | | | | 814| 7.71k|#define FALSE (0) | | | | ------------------ | | ------------------ | | __atomic_compare_exchange_n ((atomic), &gaicae_oldval, (newval), FALSE, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ? TRUE : FALSE; \ | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ | | | Branch (164:5): [True: 7.71k, False: 0] | | ------------------ | | 165| 7.71k| })) ------------------ | Branch (2511:12): [True: 0, False: 7.71k] ------------------ 2512| 7.71k|} gtype.c:type_lookup_iface_vtable_I: 632| 444k|{ 633| 444k| IFaceEntry *entry; 634| 444k| gboolean res; 635| | 636| 444k| if (!NODE_IS_IFACE (iface_node)) ------------------ | | 258| 444k|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 444k|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 444k|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 444k|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 444k|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (636:7): [True: 0, False: 444k] ------------------ 637| 0| { 638| 0| if (vtable_ptr) ------------------ | Branch (638:11): [True: 0, False: 0] ------------------ 639| 0| *vtable_ptr = NULL; 640| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 641| 0| } 642| | 643| 444k| G_ATOMIC_ARRAY_DO_TRANSACTION ------------------ | | 44| 444k|#define G_ATOMIC_ARRAY_DO_TRANSACTION(_array, _type, _C_) G_STMT_START { \ | | ------------------ | | | | 874| 444k|#define G_STMT_START do | | ------------------ | | 45| 444k| gpointer *_datap = &(_array)->data; \ | | 46| 444k| _type *transaction_data, *__check; \ | | 47| 444k| \ | | 48| 444k| __check = g_atomic_pointer_get (_datap); \ | | ------------------ | | | | 113| 444k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 444k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 444k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 444k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 444k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 444k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 444k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 444k| gapg_temp_newval; \ | | | | 119| 444k| })) | | ------------------ | | 49| 444k| do { \ | | 50| 444k| transaction_data = __check; \ | | 51| 879k| {_C_;} \ | | ------------------ | | | Branch (51:8): [True: 145k, False: 0] | | | Branch (51:8): [True: 145k, False: 299k] | | ------------------ | | 52| 444k| __check = g_atomic_pointer_get (_datap); \ | | ------------------ | | | | 113| 444k| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 444k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 114| 444k| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gpointer)); \ | | | | ------------------ | | | | | | 765| 444k|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 115| 444k| glib_typeof (*(atomic)) gapg_temp_newval; \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 116| 444k| glib_typeof ((atomic)) gapg_temp_atomic = (atomic); \ | | | | ------------------ | | | | | | 238| 444k|#define glib_typeof(t) __typeof__ (t) | | | | ------------------ | | | | 117| 444k| __atomic_load (gapg_temp_atomic, &gapg_temp_newval, __ATOMIC_SEQ_CST); \ | | | | 118| 444k| gapg_temp_newval; \ | | | | 119| 444k| })) | | ------------------ | | 53| 444k| } while (transaction_data != __check); \ | | ------------------ | | | Branch (53:14): [True: 0, False: 444k] | | ------------------ | | 54| 444k| } G_STMT_END | | ------------------ | | | | 882| 444k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 444k] | | | | ------------------ | | ------------------ ------------------ 644| 444k| (CLASSED_NODE_IFACES_ENTRIES (node), IFaceEntries, 645| | 646| 444k| entry = lookup_iface_entry_I (transaction_data, iface_node); 647| 444k| res = entry != NULL; 648| 444k| if (vtable_ptr) 649| 444k| { 650| 444k| if (entry) 651| 444k| *vtable_ptr = entry->vtable; 652| 444k| else 653| 444k| *vtable_ptr = NULL; 654| 444k| } 655| 444k| ); 656| | 657| 444k| return res; 658| 444k|} gtype.c:type_iface_ensure_dflt_vtable_Wm: 2014| 3|{ 2015| 3| g_assert (iface->data); ------------------ | | 231| 3|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 3|#define G_STMT_START do | | ------------------ | | 232| 3| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 3|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3| int _g_boolean_var_; \ | | | | | | 1018| 3| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3, False: 0] | | | | | | ------------------ | | | | | | 1019| 3| _g_boolean_var_ = 1; \ | | | | | | 1020| 3| else \ | | | | | | 1021| 3| _g_boolean_var_ = 0; \ | | | | | | 1022| 3| _g_boolean_var_; \ | | | | | | 1023| 3|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 233| 3| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 3| } G_STMT_END | | ------------------ | | | | 882| 3|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3] | | | | ------------------ | | ------------------ ------------------ 2016| | 2017| 3| if (!iface->data->iface.dflt_vtable) ------------------ | Branch (2017:7): [True: 3, False: 0] ------------------ 2018| 3| { 2019| 3| GTypeInterface *vtable = g_malloc0 (iface->data->iface.vtable_size); 2020| 3| iface->data->iface.dflt_vtable = vtable; 2021| 3| vtable->g_type = NODE_TYPE (iface); ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ 2022| 3| vtable->g_instance_type = 0; 2023| 3| if (iface->data->iface.vtable_init_base || ------------------ | Branch (2023:11): [True: 0, False: 3] ------------------ 2024| 3| iface->data->iface.dflt_init) ------------------ | Branch (2024:11): [True: 3, False: 0] ------------------ 2025| 3| { 2026| 3| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 3|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 2027| 3| if (iface->data->iface.vtable_init_base) ------------------ | Branch (2027:15): [True: 0, False: 3] ------------------ 2028| 0| iface->data->iface.vtable_init_base (vtable); 2029| 3| if (iface->data->iface.dflt_init) ------------------ | Branch (2029:15): [True: 3, False: 0] ------------------ 2030| 3| iface->data->iface.dflt_init (vtable, (gpointer) iface->data->iface.dflt_data); 2031| 3| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 3|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 2032| 3| } 2033| 3| } 2034| 3|} gtype.c:type_node_is_a_L: 3543| 4|{ 3544| 4| return type_node_check_conformities_UorL (node, iface_node, TRUE, TRUE, TRUE); ------------------ | | 818| 4|#define TRUE (!FALSE) | | ------------------ | | | | 814| 4|#define FALSE (0) | | ------------------ ------------------ return type_node_check_conformities_UorL (node, iface_node, TRUE, TRUE, TRUE); ------------------ | | 818| 4|#define TRUE (!FALSE) | | ------------------ | | | | 814| 4|#define FALSE (0) | | ------------------ ------------------ return type_node_check_conformities_UorL (node, iface_node, TRUE, TRUE, TRUE); ------------------ | | 818| 4|#define TRUE (!FALSE) | | ------------------ | | | | 814| 4|#define FALSE (0) | | ------------------ ------------------ 3545| 4|} gtype.c:type_node_check_conformities_UorL: 3504| 1.30M|{ 3505| 1.30M| gboolean match; 3506| | 3507| 1.30M| if (/* support_inheritance && */ 3508| 1.30M| NODE_IS_ANCESTOR (iface_node, node)) ------------------ | | 270| 1.30M| ((ancestor)->n_supers <= (node)->n_supers && \ | | ------------------ | | | Branch (270:10): [True: 1.30M, False: 2] | | ------------------ | | 271| 1.30M| (node)->supers[(node)->n_supers - (ancestor)->n_supers] == NODE_TYPE (ancestor)) | | ------------------ | | | | 252| 1.30M|#define NODE_TYPE(node) (node->supers[0]) | | ------------------ | | | Branch (271:3): [True: 1.00M, False: 299k] | | ------------------ ------------------ 3509| 1.00M| return TRUE; ------------------ | | 818| 1.00M|#define TRUE (!FALSE) | | ------------------ | | | | 814| 1.00M|#define FALSE (0) | | ------------------ ------------------ 3510| | 3511| 299k| support_interfaces = support_interfaces && node->is_instantiatable && NODE_IS_IFACE (iface_node); ------------------ | | 258| 599k|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 299k|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 299k|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 299k|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 299k|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 299k, False: 12] | | ------------------ ------------------ | Branch (3511:24): [True: 299k, False: 0] | Branch (3511:46): [True: 299k, False: 3] ------------------ 3512| 299k| support_prerequisites = support_prerequisites && NODE_IS_IFACE (node); ------------------ | | 258| 299k|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 18|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 18|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 18|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 18|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 3, False: 15] | | ------------------ ------------------ | Branch (3512:27): [True: 18, False: 299k] ------------------ 3513| 299k| match = FALSE; ------------------ | | 814| 299k|#define FALSE (0) ------------------ 3514| 299k| if (support_interfaces) ------------------ | Branch (3514:7): [True: 299k, False: 15] ------------------ 3515| 299k| { 3516| 299k| if (have_lock) ------------------ | Branch (3516:11): [True: 0, False: 299k] ------------------ 3517| 0| { 3518| 0| if (type_lookup_iface_entry_L (node, iface_node)) ------------------ | Branch (3518:8): [True: 0, False: 0] ------------------ 3519| 0| match = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 3520| 0| } 3521| 299k| else 3522| 299k| { 3523| 299k| if (type_lookup_iface_vtable_I (node, iface_node, NULL)) ------------------ | Branch (3523:8): [True: 299k, False: 3] ------------------ 3524| 299k| match = TRUE; ------------------ | | 818| 299k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 299k|#define FALSE (0) | | ------------------ ------------------ 3525| 299k| } 3526| 299k| } 3527| 299k| if (!match && ------------------ | Branch (3527:7): [True: 18, False: 299k] ------------------ 3528| 18| support_prerequisites) ------------------ | Branch (3528:7): [True: 3, False: 15] ------------------ 3529| 3| { 3530| 3| if (!have_lock) ------------------ | Branch (3530:11): [True: 3, False: 0] ------------------ 3531| 3| G_READ_LOCK (&type_rw_lock); ------------------ | | 126| 3|#define G_READ_LOCK(rw_lock) g_rw_lock_reader_lock (rw_lock) ------------------ 3532| 3| if (support_prerequisites && type_lookup_prerequisite_L (node, NODE_TYPE (iface_node))) ------------------ | | 252| 3|#define NODE_TYPE(node) (node->supers[0]) ------------------ | Branch (3532:11): [True: 3, False: 0] | Branch (3532:36): [True: 0, False: 3] ------------------ 3533| 0| match = TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 3534| 3| if (!have_lock) ------------------ | Branch (3534:11): [True: 3, False: 0] ------------------ 3535| 3| G_READ_UNLOCK (&type_rw_lock); ------------------ | | 127| 3|#define G_READ_UNLOCK(rw_lock) g_rw_lock_reader_unlock (rw_lock) ------------------ 3536| 3| } 3537| 299k| return match; 3538| 1.30M|} gtype.c:type_lookup_prerequisite_L: 663| 3|{ 664| 3| if (NODE_IS_IFACE (iface) && IFACE_NODE_N_PREREQUISITES (iface)) ------------------ | | 258| 6|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 3|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 3|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 3|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 3|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 3, False: 0] | | ------------------ ------------------ if (NODE_IS_IFACE (iface) && IFACE_NODE_N_PREREQUISITES (iface)) ------------------ | | 261| 3|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) | | ------------------ | | | Branch (261:42): [True: 0, False: 3] | | ------------------ ------------------ 665| 0| { 666| 0| GType *prerequisites = IFACE_NODE_PREREQUISITES (iface) - 1; ------------------ | | 262| 0|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 667| 0| guint n_prerequisites = IFACE_NODE_N_PREREQUISITES (iface); ------------------ | | 261| 0|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ 668| | 669| 0| do 670| 0| { 671| 0| guint i; 672| 0| GType *check; 673| | 674| 0| i = (n_prerequisites + 1) >> 1; 675| 0| check = prerequisites + i; 676| 0| if (prerequisite_type == *check) ------------------ | Branch (676:8): [True: 0, False: 0] ------------------ 677| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 678| 0| else if (prerequisite_type > *check) ------------------ | Branch (678:13): [True: 0, False: 0] ------------------ 679| 0| { 680| 0| n_prerequisites -= i; 681| 0| prerequisites = check; 682| 0| } 683| 0| else /* if (prerequisite_type < *check) */ 684| 0| n_prerequisites = i - 1; 685| 0| } 686| 0| while (n_prerequisites); ------------------ | Branch (686:14): [True: 0, False: 0] ------------------ 687| 0| } 688| 3| return FALSE; ------------------ | | 814| 3|#define FALSE (0) ------------------ 689| 3|} gtype.c:type_node_conforms_to_U: 3552| 1.30M|{ 3553| 1.30M| return type_node_check_conformities_UorL (node, iface_node, support_interfaces, support_prerequisites, FALSE); ------------------ | | 814| 1.30M|#define FALSE (0) ------------------ 3554| 1.30M|} gtype.c:type_get_qdata_L: 3699| 205|{ 3700| 205| GData *gdata = node->global_gdata; 3701| | 3702| 205| if (quark && gdata && gdata->n_qdatas) ------------------ | Branch (3702:7): [True: 205, False: 0] | Branch (3702:16): [True: 108, False: 97] | Branch (3702:25): [True: 108, False: 0] ------------------ 3703| 108| { 3704| 108| QData *qdatas = gdata->qdatas - 1; 3705| 108| guint n_qdatas = gdata->n_qdatas; 3706| | 3707| 108| do 3708| 115| { 3709| 115| guint i; 3710| 115| QData *check; 3711| | 3712| 115| i = (n_qdatas + 1) / 2; 3713| 115| check = qdatas + i; 3714| 115| if (quark == check->quark) ------------------ | Branch (3714:8): [True: 98, False: 17] ------------------ 3715| 98| return check->data; 3716| 17| else if (quark > check->quark) ------------------ | Branch (3716:13): [True: 17, False: 0] ------------------ 3717| 17| { 3718| 17| n_qdatas -= i; 3719| 17| qdatas = check; 3720| 17| } 3721| 0| else /* if (quark < check->quark) */ 3722| 0| n_qdatas = i - 1; 3723| 115| } 3724| 108| while (n_qdatas); ------------------ | Branch (3724:14): [True: 7, False: 10] ------------------ 3725| 108| } 3726| 107| return NULL; 3727| 205|} gtype.c:type_set_qdata_W: 3769| 100|{ 3770| 100| GData *gdata; 3771| 100| QData *qdata; 3772| 100| guint i; 3773| | 3774| | /* setup qdata list if necessary */ 3775| 100| if (!node->global_gdata) ------------------ | Branch (3775:7): [True: 97, False: 3] ------------------ 3776| 97| node->global_gdata = g_new0 (GData, 1); ------------------ | | 307| 97|#define g_new0(struct_type, n_structs) _G_NEW (struct_type, n_structs, malloc0) | | ------------------ | | | | 235| 97| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 97|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 236| 97| gsize __n = (gsize) (n_structs); \ | | | | 237| 97| gsize __s = sizeof (struct_type); \ | | | | 238| 97| gpointer __p; \ | | | | 239| 97| if (__s == 1) \ | | | | ------------------ | | | | | Branch (239:8): [True: 0, False: 97] | | | | ------------------ | | | | 240| 97| __p = g_##func (__n); \ | | | | 241| 97| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (241:13): [True: 97, False: 0] | | | | ------------------ | | | | 242| 97| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 97|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 97|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (242:14): [True: 0, False: 97] | | | | | Branch (242:26): [True: 97, False: 0] | | | | ------------------ | | | | 243| 97| __p = g_##func (__n * __s); \ | | | | 244| 97| else \ | | | | 245| 97| __p = g_##func##_n (__n, __s); \ | | | | 246| 97| __p; \ | | | | 247| 97| })) | | ------------------ ------------------ 3777| 100| gdata = node->global_gdata; 3778| | 3779| | /* try resetting old data */ 3780| 100| qdata = gdata->qdatas; 3781| 103| for (i = 0; i < gdata->n_qdatas; i++) ------------------ | Branch (3781:15): [True: 3, False: 100] ------------------ 3782| 3| if (qdata[i].quark == quark) ------------------ | Branch (3782:9): [True: 0, False: 3] ------------------ 3783| 0| { 3784| 0| qdata[i].data = data; 3785| 0| return; 3786| 0| } 3787| | 3788| | /* add new entry */ 3789| 100| gdata->n_qdatas++; 3790| 100| gdata->qdatas = g_renew (QData, gdata->qdatas, gdata->n_qdatas); ------------------ | | 321| 100|#define g_renew(struct_type, mem, n_structs) _G_RENEW (struct_type, mem, n_structs, realloc) | | ------------------ | | | | 249| 100| (struct_type *) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 100|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 250| 100| gsize __n = (gsize) (n_structs); \ | | | | 251| 100| gsize __s = sizeof (struct_type); \ | | | | 252| 100| gpointer __p = (gpointer) (mem); \ | | | | 253| 100| if (__s == 1) \ | | | | ------------------ | | | | | Branch (253:8): [True: 0, False: 100] | | | | ------------------ | | | | 254| 100| __p = g_##func (__p, __n); \ | | | | 255| 100| else if (__builtin_constant_p (__n) && \ | | | | ------------------ | | | | | Branch (255:13): [True: 0, False: 100] | | | | ------------------ | | | | 256| 100| (__s == 0 || __n <= G_MAXSIZE / __s)) \ | | | | ------------------ | | | | | | 84| 0|#define G_MAXSIZE G_MAXULONG | | | | | | ------------------ | | | | | | | | 38| 0|#define G_MAXULONG ULONG_MAX | | | | | | ------------------ | | | | ------------------ | | | | | Branch (256:14): [True: 0, False: 0] | | | | | Branch (256:26): [True: 0, False: 0] | | | | ------------------ | | | | 257| 100| __p = g_##func (__p, __n * __s); \ | | | | 258| 100| else \ | | | | 259| 100| __p = g_##func##_n (__p, __n, __s); \ | | | | 260| 100| __p; \ | | | | 261| 100| })) | | ------------------ ------------------ 3791| 100| qdata = gdata->qdatas; 3792| 103| for (i = 0; i < gdata->n_qdatas - 1; i++) ------------------ | Branch (3792:15): [True: 3, False: 100] ------------------ 3793| 3| if (qdata[i].quark > quark) ------------------ | Branch (3793:9): [True: 0, False: 3] ------------------ 3794| 0| break; 3795| 100| memmove (qdata + i + 1, qdata + i, sizeof (qdata[0]) * (gdata->n_qdatas - i - 1)); 3796| 100| qdata[i].quark = quark; 3797| 100| qdata[i].data = data; 3798| 100|} gtype.c:type_add_flags_W: 3831| 97|{ 3832| 97| guint dflags; 3833| | 3834| 97| g_return_if_fail ((flags & ~TYPE_FLAG_MASK) == 0); ------------------ | | 630| 97| G_STMT_START { \ | | ------------------ | | | | 874| 97|#define G_STMT_START do | | ------------------ | | 631| 97| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 97|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 97| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 97|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 97| int _g_boolean_var_; \ | | | | | | 1018| 97| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 97, False: 0] | | | | | | ------------------ | | | | | | 1019| 97| _g_boolean_var_ = 1; \ | | | | | | 1020| 97| else \ | | | | | | 1021| 97| _g_boolean_var_ = 0; \ | | | | | | 1022| 97| _g_boolean_var_; \ | | | | | | 1023| 97|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 97, False: 0] | | | | ------------------ | | ------------------ | | 632| 97| { } \ | | 633| 97| else \ | | 634| 97| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 97| } G_STMT_END | | ------------------ | | | | 882| 97|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 97] | | | | ------------------ | | ------------------ ------------------ 3835| 97| g_return_if_fail (node != NULL); ------------------ | | 630| 97| G_STMT_START { \ | | ------------------ | | | | 874| 97|#define G_STMT_START do | | ------------------ | | 631| 97| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 97|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 97| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 97|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 97| int _g_boolean_var_; \ | | | | | | 1018| 97| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 97, False: 0] | | | | | | ------------------ | | | | | | 1019| 97| _g_boolean_var_ = 1; \ | | | | | | 1020| 97| else \ | | | | | | 1021| 97| _g_boolean_var_ = 0; \ | | | | | | 1022| 97| _g_boolean_var_; \ | | | | | | 1023| 97|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 97, False: 0] | | | | ------------------ | | ------------------ | | 632| 97| { } \ | | 633| 97| else \ | | 634| 97| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 97| } G_STMT_END | | ------------------ | | | | 882| 97|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 97] | | | | ------------------ | | ------------------ ------------------ 3836| | 3837| 97| if ((flags & TYPE_FLAG_MASK) && node->is_classed && node->data && node->data->class.class) ------------------ | | 146| 97|#define TYPE_FLAG_MASK (G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT) ------------------ | Branch (3837:7): [True: 9, False: 88] | Branch (3837:35): [True: 7, False: 2] | Branch (3837:55): [True: 0, False: 7] | Branch (3837:69): [True: 0, False: 0] ------------------ 3838| 0| g_warning ("tagging type '%s' as abstract after class initialization", NODE_NAME (node)); ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 3839| 97| dflags = GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags)); ------------------ | | 99| 97|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 3840| 97| dflags |= flags; 3841| 97| type_set_qdata_W (node, static_quark_type_flags, GUINT_TO_POINTER (dflags)); ------------------ | | 102| 97|#define GUINT_TO_POINTER(u) ((gpointer) (gulong) (u)) ------------------ 3842| 97|} gtype.c:type_node_fundamental_info_I: 529| 203|{ 530| 203| GType ftype = NODE_FUNDAMENTAL_TYPE (node); ------------------ | | 254| 203|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) ------------------ 531| | 532| 203| if (ftype != NODE_TYPE (node)) ------------------ | | 252| 203|#define NODE_TYPE(node) (node->supers[0]) ------------------ | Branch (532:7): [True: 5, False: 198] ------------------ 533| 5| node = lookup_type_node_I (ftype); 534| | 535| 203| return node ? G_STRUCT_MEMBER_P (node, -SIZEOF_FUNDAMENTAL_INFO) : NULL; ------------------ | | 860| 812| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) | | ------------------ | | | Branch (860:50): [Folded, False: 203] | | | Branch (860:50): [Folded, False: 0] | | | Branch (860:50): [Folded, False: 203] | | ------------------ ------------------ | Branch (535:10): [True: 203, False: 0] ------------------ 536| 203|} gtype.c:type_check_is_value_type_U: 4207| 7.70k|{ 4208| 7.70k| GTypeFlags tflags = G_TYPE_FLAG_VALUE_ABSTRACT; 4209| 7.70k| TypeNode *node; 4210| | 4211| | /* common path speed up */ 4212| 7.70k| node = lookup_type_node_I (type); 4213| 7.70k| if (node && node->mutatable_check_cache) ------------------ | Branch (4213:7): [True: 7.70k, False: 0] | Branch (4213:15): [True: 7.70k, False: 1] ------------------ 4214| 7.70k| return TRUE; ------------------ | | 818| 7.70k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 7.70k|#define FALSE (0) | | ------------------ ------------------ 4215| | 4216| 1| G_READ_LOCK (&type_rw_lock); ------------------ | | 126| 1|#define G_READ_LOCK(rw_lock) g_rw_lock_reader_lock (rw_lock) ------------------ 4217| 1| restart_check: 4218| 1| if (node) ------------------ | Branch (4218:7): [True: 1, False: 0] ------------------ 4219| 1| { 4220| 1| if (node->data && NODE_REFCOUNT (node) > 0 && ------------------ | | 256| 1|#define NODE_REFCOUNT(node) ((guint) g_atomic_int_get ((int *) &(node)->ref_count)) | | ------------------ | | | | 96| 1| (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 97| 1| G_STATIC_ASSERT (sizeof *(atomic) == sizeof (gint)); \ | | | | ------------------ | | | | | | 765| 1|#define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED | | | | ------------------ | | | | 98| 1| gint gaig_temp; \ | | | | 99| 1| (void) (0 ? *(atomic) ^ *(atomic) : 1); \ | | | | ------------------ | | | | | Branch (99:13): [Folded, False: 1] | | | | ------------------ | | | | 100| 1| __atomic_load ((gint *)(atomic), &gaig_temp, __ATOMIC_SEQ_CST); \ | | | | 101| 1| (gint) gaig_temp; \ | | | | 102| 1| })) | | ------------------ ------------------ | Branch (4220:11): [True: 1, False: 0] | Branch (4220:25): [True: 1, False: 0] ------------------ 4221| 1| node->data->common.value_table->value_init) ------------------ | Branch (4221:4): [True: 1, False: 0] ------------------ 4222| 1| tflags = GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags)); ------------------ | | 99| 1|#define GPOINTER_TO_UINT(p) ((guint) (gulong) (p)) ------------------ 4223| 0| else if (NODE_IS_IFACE (node)) ------------------ | | 258| 0|#define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 254| 0|#define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers]) | | ------------------ | | #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE) | | ------------------ | | | | 68| 0|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | | | ------------------ | | | | | | 221| 0|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | | | ------------------ | | | | | | | | 210| 0|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (258:31): [True: 0, False: 0] | | ------------------ ------------------ 4224| 0| { 4225| 0| guint i; 4226| | 4227| 0| for (i = 0; i < IFACE_NODE_N_PREREQUISITES (node); i++) ------------------ | | 261| 0|#define IFACE_NODE_N_PREREQUISITES(node) ((node)->n_prerequisites) ------------------ | Branch (4227:16): [True: 0, False: 0] ------------------ 4228| 0| { 4229| 0| GType prtype = IFACE_NODE_PREREQUISITES (node)[i]; ------------------ | | 262| 0|#define IFACE_NODE_PREREQUISITES(node) ((node)->prerequisites) ------------------ 4230| 0| TypeNode *prnode = lookup_type_node_I (prtype); 4231| | 4232| 0| if (prnode->is_instantiatable) ------------------ | Branch (4232:12): [True: 0, False: 0] ------------------ 4233| 0| { 4234| 0| type = prtype; 4235| 0| node = lookup_type_node_I (type); 4236| 0| goto restart_check; 4237| 0| } 4238| 0| } 4239| 0| } 4240| 1| } 4241| 1| G_READ_UNLOCK (&type_rw_lock); ------------------ | | 127| 1|#define G_READ_UNLOCK(rw_lock) g_rw_lock_reader_unlock (rw_lock) ------------------ 4242| | 4243| 1| return !(tflags & G_TYPE_FLAG_VALUE_ABSTRACT); 4244| 1|} gtype.c:gobject_init: 4420| 2|{ 4421| 2| const gchar *env_string; 4422| 2| GTypeInfo info; 4423| 2| TypeNode *node; 4424| 2| GType type G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */; 4425| | 4426| | /* Ensure GLib is initialized first, see 4427| | * https://bugzilla.gnome.org/show_bug.cgi?id=756139 4428| | */ 4429| 2| GLIB_PRIVATE_CALL (glib_init) (); ------------------ | | 94| 2|#define GLIB_PRIVATE_CALL(symbol) (glib__private__()->symbol) ------------------ 4430| | 4431| 2| G_WRITE_LOCK (&type_rw_lock); ------------------ | | 128| 2|#define G_WRITE_LOCK(rw_lock) g_rw_lock_writer_lock (rw_lock) ------------------ 4432| | 4433| | /* setup GObject library wide debugging flags */ 4434| 2| env_string = g_getenv ("GOBJECT_DEBUG"); 4435| 2| if (env_string != NULL) ------------------ | Branch (4435:7): [True: 0, False: 2] ------------------ 4436| 0| { 4437| 0| GDebugKey debug_keys[] = { 4438| 0| { "objects", G_TYPE_DEBUG_OBJECTS }, 4439| 0| { "instance-count", G_TYPE_DEBUG_INSTANCE_COUNT }, 4440| 0| { "signals", G_TYPE_DEBUG_SIGNALS }, 4441| 0| }; 4442| | 4443| 0| _g_type_debug_flags = g_parse_debug_string (env_string, debug_keys, G_N_ELEMENTS (debug_keys)); ------------------ | | 840| 0|#define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0])) ------------------ 4444| 0| } 4445| | 4446| | /* quarks */ 4447| 2| static_quark_type_flags = g_quark_from_static_string ("-g-type-private--GTypeFlags"); 4448| 2| static_quark_iface_holder = g_quark_from_static_string ("-g-type-private--IFaceHolder"); 4449| 2| static_quark_dependants_array = g_quark_from_static_string ("-g-type-private--dependants-array"); 4450| | 4451| | /* type qname hash table */ 4452| 2| static_type_nodes_ht = g_hash_table_new (g_str_hash, g_str_equal); 4453| | 4454| | /* invalid type G_TYPE_INVALID (0) 4455| | */ 4456| 2| static_fundamental_type_nodes[0] = NULL; 4457| | 4458| | /* void type G_TYPE_NONE 4459| | */ 4460| 2| node = type_node_fundamental_new_W (G_TYPE_NONE, g_intern_static_string ("void"), 0); ------------------ | | 62| 2|#define G_TYPE_NONE G_TYPE_MAKE_FUNDAMENTAL (1) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 4461| 2| type = NODE_TYPE (node); ------------------ | | 252| 2|#define NODE_TYPE(node) (node->supers[0]) ------------------ 4462| 2| g_assert (type == G_TYPE_NONE); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 4463| | 4464| | /* interface fundamental type G_TYPE_INTERFACE (!classed) 4465| | */ 4466| 2| memset (&info, 0, sizeof (info)); 4467| 2| node = type_node_fundamental_new_W (G_TYPE_INTERFACE, g_intern_static_string ("GInterface"), G_TYPE_FLAG_DERIVABLE); ------------------ | | 68| 2|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 4468| 2| type = NODE_TYPE (node); ------------------ | | 252| 2|#define NODE_TYPE(node) (node->supers[0]) ------------------ 4469| 2| type_data_make_W (node, &info, NULL); 4470| 2| g_assert (type == G_TYPE_INTERFACE); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 4471| | 4472| 2| G_WRITE_UNLOCK (&type_rw_lock); ------------------ | | 129| 2|#define G_WRITE_UNLOCK(rw_lock) g_rw_lock_writer_unlock (rw_lock) ------------------ 4473| | 4474| 2| _g_value_c_init (); 4475| | 4476| | /* G_TYPE_TYPE_PLUGIN 4477| | */ 4478| 2| g_type_ensure (g_type_plugin_get_type ()); 4479| | 4480| | /* G_TYPE_* value types 4481| | */ 4482| 2| _g_value_types_init (); 4483| | 4484| | /* G_TYPE_ENUM & G_TYPE_FLAGS 4485| | */ 4486| 2| _g_enum_types_init (); 4487| | 4488| | /* G_TYPE_BOXED 4489| | */ 4490| 2| _g_boxed_type_init (); 4491| | 4492| | /* G_TYPE_PARAM 4493| | */ 4494| 2| _g_param_type_init (); 4495| | 4496| | /* G_TYPE_OBJECT 4497| | */ 4498| 2| _g_object_type_init (); 4499| | 4500| | /* G_TYPE_PARAM_* pspec types 4501| | */ 4502| 2| _g_param_spec_types_init (); 4503| | 4504| | /* Value Transformations 4505| | */ 4506| 2| _g_value_transforms_init (); 4507| | 4508| | /* Signal system 4509| | */ 4510| 2| _g_signal_init (); 4511| 2|} ginputstream.c:g_input_stream_get_type_once: 1762| 1|#define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2035| 1| _G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER(TypeName, type_name, TYPE_PARENT, flags) \ | | ------------------ | | | | 2013| 1|type_name##_get_type_once (void) \ | | | | 2014| 1|{ \ | | | | 2015| 1| GType g_define_type_id = \ | | | | 2016| 1| g_type_register_static_simple (TYPE_PARENT, \ | | | | 2017| 1| g_intern_static_string (#TypeName), \ | | | | 2018| 1| sizeof (TypeName##Class), \ | | | | 2019| 1| (GClassInitFunc)(void (*)(void)) type_name##_class_intern_init, \ | | | | 2020| 1| sizeof (TypeName), \ | | | | 2021| 1| (GInstanceInitFunc)(void (*)(void)) type_name##_init, \ | | | | 2022| 1| (GTypeFlags) flags); \ | | | | 2023| 1| { /* custom code follows */ | | ------------------ ------------------ #define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2026| 1| } \ | | 2027| 1| return g_define_type_id; \ | | 2028| 1|} /* closes type_name##_get_type_once() */ ------------------ ginputstream.c:g_input_stream_class_intern_init: 1960| 1|static void type_name##_class_intern_init (gpointer klass) \ 1961| 1|{ \ 1962| 1| type_name##_parent_class = g_type_class_peek_parent (klass); \ 1963| 1| if (TypeName##_private_offset != 0) \ ------------------ | Branch (1963:7): [True: 1, False: 0] ------------------ 1964| 1| g_type_class_adjust_private_offset (klass, &TypeName##_private_offset); \ 1965| 1| type_name##_class_init ((TypeName##Class*) klass); \ 1966| 1|} ginputstream.c:g_input_stream_get_instance_private: 1990| 3.85k|type_name##_get_instance_private (TypeName *self) \ 1991| 3.85k|{ \ 1992| 3.85k| return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); \ ------------------ | | 860| 3.85k| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1993| 3.85k|} \ gmemoryinputstream.c:g_memory_input_stream_get_type_once: 1618| 1|#define G_DEFINE_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, 0) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2035| 1| _G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER(TypeName, type_name, TYPE_PARENT, flags) \ | | ------------------ | | | | 2013| 1|type_name##_get_type_once (void) \ | | | | 2014| 1|{ \ | | | | 2015| 1| GType g_define_type_id = \ | | | | 2016| 1| g_type_register_static_simple (TYPE_PARENT, \ | | | | 2017| 1| g_intern_static_string (#TypeName), \ | | | | 2018| 1| sizeof (TypeName##Class), \ | | | | 2019| 1| (GClassInitFunc)(void (*)(void)) type_name##_class_intern_init, \ | | | | 2020| 1| sizeof (TypeName), \ | | | | 2021| 1| (GInstanceInitFunc)(void (*)(void)) type_name##_init, \ | | | | 2022| 1| (GTypeFlags) flags); \ | | | | 2023| 1| { /* custom code follows */ | | ------------------ ------------------ #define G_DEFINE_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, 0) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2026| 1| } \ | | 2027| 1| return g_define_type_id; \ | | 2028| 1|} /* closes type_name##_get_type_once() */ ------------------ gmemoryinputstream.c:g_memory_input_stream_class_intern_init: 1960| 1|static void type_name##_class_intern_init (gpointer klass) \ 1961| 1|{ \ 1962| 1| type_name##_parent_class = g_type_class_peek_parent (klass); \ 1963| 1| if (TypeName##_private_offset != 0) \ ------------------ | Branch (1963:7): [True: 1, False: 0] ------------------ 1964| 1| g_type_class_adjust_private_offset (klass, &TypeName##_private_offset); \ 1965| 1| type_name##_class_init ((TypeName##Class*) klass); \ 1966| 1|} gmemoryinputstream.c:g_memory_input_stream_get_instance_private: 1990| 3.85k|type_name##_get_instance_private (TypeName *self) \ 1991| 3.85k|{ \ 1992| 3.85k| return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); \ ------------------ | | 860| 3.85k| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1993| 3.85k|} \ gboxed.c:g_value_array_get_type_once: 2106| 2|#define G_DEFINE_BOXED_TYPE_WITH_CODE(TypeName, type_name, copy_func, free_func, _C_) _G_DEFINE_BOXED_TYPE_BEGIN (TypeName, type_name, copy_func, free_func) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2129| 2|type_name##_get_type_once (void) \ | | 2130| 2|{ \ | | 2131| 2| GType (* _g_register_boxed) \ | | 2132| 2| (const gchar *, \ | | 2133| 2| union \ | | 2134| 2| { \ | | 2135| 2| TypeName * (*do_copy_type) (TypeName *); \ | | 2136| 2| TypeName * (*do_const_copy_type) (const TypeName *); \ | | 2137| 2| GBoxedCopyFunc do_copy_boxed; \ | | 2138| 2| } __attribute__((__transparent_union__)), \ | | 2139| 2| union \ | | 2140| 2| { \ | | 2141| 2| void (* do_free_type) (TypeName *); \ | | 2142| 2| GBoxedFreeFunc do_free_boxed; \ | | 2143| 2| } __attribute__((__transparent_union__)) \ | | 2144| 2| ) = g_boxed_type_register_static; \ | | 2145| 2| GType g_define_type_id = \ | | 2146| 2| _g_register_boxed (g_intern_static_string (#TypeName), copy_func, free_func); \ | | 2147| 2| { /* custom code follows */ ------------------ #define G_DEFINE_BOXED_TYPE_WITH_CODE(TypeName, type_name, copy_func, free_func, _C_) _G_DEFINE_BOXED_TYPE_BEGIN (TypeName, type_name, copy_func, free_func) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2026| 2| } \ | | 2027| 2| return g_define_type_id; \ | | 2028| 2|} /* closes type_name##_get_type_once() */ ------------------ gvaluetypes.c:g_gtype_get_type_once: 2200| 2|#define G_DEFINE_POINTER_TYPE_WITH_CODE(TypeName, type_name, _C_) _G_DEFINE_POINTER_TYPE_BEGIN (TypeName, type_name) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2219| 2|type_name##_get_type_once (void) \ | | 2220| 2|{ \ | | 2221| 2| GType g_define_type_id = \ | | 2222| 2| g_pointer_type_register_static (g_intern_static_string (#TypeName)); \ | | 2223| 2| { /* custom code follows */ ------------------ #define G_DEFINE_POINTER_TYPE_WITH_CODE(TypeName, type_name, _C_) _G_DEFINE_POINTER_TYPE_BEGIN (TypeName, type_name) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2026| 2| } \ | | 2027| 2| return g_define_type_id; \ | | 2028| 2|} /* closes type_name##_get_type_once() */ ------------------ g_type_plugin_get_type: 82| 2|{ 83| 2| static GType type_plugin_type = 0; 84| | 85| 2| if (!type_plugin_type) ------------------ | Branch (85:7): [True: 2, False: 0] ------------------ 86| 2| { 87| 2| const GTypeInfo type_plugin_info = { 88| 2| sizeof (GTypePluginClass), 89| 2| NULL, /* base_init */ 90| 2| NULL, /* base_finalize */ 91| 2| 0, /* class_init */ 92| 2| NULL, /* class_destroy */ 93| 2| NULL, /* class_data */ 94| 2| 0, /* instance_size */ 95| 2| 0, /* n_preallocs */ 96| 2| NULL, /* instance_init */ 97| 2| NULL, /* value_table */ 98| 2| }; 99| | 100| 2| type_plugin_type = g_type_register_static (G_TYPE_INTERFACE, g_intern_static_string ("GTypePlugin"), &type_plugin_info, 0); ------------------ | | 68| 2|#define G_TYPE_INTERFACE G_TYPE_MAKE_FUNDAMENTAL (2) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 101| 2| } 102| | 103| 2| return type_plugin_type; 104| 2|} _g_value_c_init: 140| 2|{ 141| 2| transform_array = g_bsearch_array_create (&transform_bconfig); 142| 2|} g_value_init: 164| 3.85k|{ 165| 3.85k| GTypeValueTable *value_table; 166| | /* g_return_val_if_fail (G_TYPE_IS_VALUE (g_type), NULL); be more elaborate below */ 167| 3.85k| g_return_val_if_fail (value != NULL, NULL); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 168| | /* g_return_val_if_fail (G_VALUE_TYPE (value) == 0, NULL); be more elaborate below */ 169| | 170| 3.85k| value_table = g_type_value_table_peek (g_type); 171| | 172| 3.85k| if (value_table && G_VALUE_TYPE (value) == 0) ------------------ | | 59| 3.85k|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ | Branch (172:7): [True: 3.85k, False: 0] | Branch (172:22): [True: 3.85k, False: 0] ------------------ 173| 3.85k| { 174| | /* setup and init */ 175| 3.85k| value_meminit (value, g_type); 176| 3.85k| value_table->value_init (value); 177| 3.85k| } 178| 0| else if (G_VALUE_TYPE (value)) ------------------ | | 59| 0|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) | | ------------------ | | | Branch (59:30): [True: 0, False: 0] | | ------------------ ------------------ 179| 0| g_warning ("%s: cannot initialize GValue with type '%s', the value has already been initialized as '%s'", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) ------------------ 180| 0| G_STRLOC, 181| 0| g_type_name (g_type), 182| 0| g_type_name (G_VALUE_TYPE (value))); 183| 0| else /* !G_TYPE_IS_VALUE (g_type) */ 184| 0| g_warning ("%s: cannot initialize GValue with type '%s', %s", ------------------ | | 345| 0|#define g_warning(...) g_log (G_LOG_DOMAIN, \ | | 346| 0| G_LOG_LEVEL_WARNING, \ | | 347| 0| __VA_ARGS__) | | ------------------ | | | Branch (347:32): [True: 0, False: 0] | | ------------------ ------------------ 185| 3.85k| G_STRLOC, 186| 3.85k| g_type_name (g_type), 187| 3.85k| value_table ? "this type is abstract with regards to GValue use, use a more specific (derived) type" : "this type has no GTypeValueTable implementation"); 188| 3.85k| return value; 189| 3.85k|} g_value_copy: 201| 3.85k|{ 202| 3.85k| g_return_if_fail (src_value); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 203| 3.85k| g_return_if_fail (dest_value); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 204| 3.85k| g_return_if_fail (g_value_type_compatible (G_VALUE_TYPE (src_value), G_VALUE_TYPE (dest_value))); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 205| | 206| 3.85k| if (src_value != dest_value) ------------------ | Branch (206:7): [True: 3.85k, False: 0] ------------------ 207| 3.85k| { 208| 3.85k| GType dest_type = G_VALUE_TYPE (dest_value); ------------------ | | 59| 3.85k|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ 209| 3.85k| GTypeValueTable *value_table = g_type_value_table_peek (dest_type); 210| | 211| 3.85k| g_return_if_fail (value_table); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 212| | 213| | /* make sure dest_value's value is free()d */ 214| 3.85k| if (value_table->value_free) ------------------ | Branch (214:11): [True: 3.85k, False: 0] ------------------ 215| 3.85k| value_table->value_free (dest_value); 216| | 217| | /* setup and copy */ 218| 3.85k| value_meminit (dest_value, dest_type); 219| 3.85k| value_table->value_copy (src_value, dest_value); 220| 3.85k| } 221| 3.85k|} g_value_reset: 234| 1|{ 235| 1| GTypeValueTable *value_table; 236| 1| GType g_type; 237| | 238| 1| g_return_val_if_fail (value, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 239| 1| g_type = G_VALUE_TYPE (value); ------------------ | | 59| 1|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ 240| | 241| 1| value_table = g_type_value_table_peek (g_type); 242| 1| g_return_val_if_fail (value_table, NULL); ------------------ | | 643| 1| G_STMT_START { \ | | ------------------ | | | | 874| 1|#define G_STMT_START do | | ------------------ | | 644| 1| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 1|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 1| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 1|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 1| int _g_boolean_var_; \ | | | | | | 1018| 1| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 1, False: 0] | | | | | | ------------------ | | | | | | 1019| 1| _g_boolean_var_ = 1; \ | | | | | | 1020| 1| else \ | | | | | | 1021| 1| _g_boolean_var_ = 0; \ | | | | | | 1022| 1| _g_boolean_var_; \ | | | | | | 1023| 1|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 645| 1| { } \ | | 646| 1| else \ | | 647| 1| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 1| } G_STMT_END | | ------------------ | | | | 882| 1|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 243| | 244| | /* make sure value's value is free()d */ 245| 1| if (value_table->value_free) ------------------ | Branch (245:7): [True: 1, False: 0] ------------------ 246| 1| value_table->value_free (value); 247| | 248| | /* setup and init */ 249| 1| value_meminit (value, g_type); 250| 1| value_table->value_init (value); 251| | 252| 1| return value; 253| 1|} g_value_unset: 266| 3.85k|{ 267| 3.85k| GTypeValueTable *value_table; 268| | 269| 3.85k| if (value->g_type == 0) ------------------ | Branch (269:7): [True: 0, False: 3.85k] ------------------ 270| 0| return; 271| | 272| 3.85k| g_return_if_fail (value); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 273| | 274| 3.85k| value_table = g_type_value_table_peek (G_VALUE_TYPE (value)); ------------------ | | 59| 3.85k|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ 275| 3.85k| g_return_if_fail (value_table); ------------------ | | 630| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 631| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 632| 3.85k| { } \ | | 633| 3.85k| else \ | | 634| 3.85k| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 276| | 277| 3.85k| if (value_table->value_free) ------------------ | Branch (277:7): [True: 3.85k, False: 0] ------------------ 278| 3.85k| value_table->value_free (value); 279| 3.85k| memset (value, 0, sizeof (*value)); 280| 3.85k|} g_value_register_transform_func: 522| 340|{ 523| 340| TransformEntry entry; 524| | 525| | /* these checks won't pass for dynamic types. 526| | * g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (src_type)); 527| | * g_return_if_fail (G_TYPE_HAS_VALUE_TABLE (dest_type)); 528| | */ 529| 340| g_return_if_fail (transform_func != NULL); ------------------ | | 630| 340| G_STMT_START { \ | | ------------------ | | | | 874| 340|#define G_STMT_START do | | ------------------ | | 631| 340| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 340|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 340| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 340|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 340| int _g_boolean_var_; \ | | | | | | 1018| 340| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 340, False: 0] | | | | | | ------------------ | | | | | | 1019| 340| _g_boolean_var_ = 1; \ | | | | | | 1020| 340| else \ | | | | | | 1021| 340| _g_boolean_var_ = 0; \ | | | | | | 1022| 340| _g_boolean_var_; \ | | | | | | 1023| 340|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 340, False: 0] | | | | ------------------ | | ------------------ | | 632| 340| { } \ | | 633| 340| else \ | | 634| 340| { \ | | 635| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 636| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 637| 0| #expr); \ | | 638| 0| return; \ | | 639| 0| } \ | | 640| 340| } G_STMT_END | | ------------------ | | | | 882| 340|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 340] | | | | ------------------ | | ------------------ ------------------ 530| | 531| 340| entry.src_type = src_type; 532| 340| entry.dest_type = dest_type; 533| | 534| |#if 0 /* let transform function replacement be a valid operation */ 535| | if (g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry)) 536| | g_warning ("reregistering value transformation function (%p) for '%s' to '%s'", 537| | transform_func, 538| | g_type_name (src_type), 539| | g_type_name (dest_type)); 540| |#endif 541| | 542| 340| entry.func = transform_func; 543| 340| transform_array = g_bsearch_array_replace (transform_array, &transform_bconfig, &entry); 544| 340|} g_value_type_compatible: 582| 7.70k|{ 583| 7.70k| g_return_val_if_fail (src_type, FALSE); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 584| 7.70k| g_return_val_if_fail (dest_type, FALSE); ------------------ | | 643| 7.70k| G_STMT_START { \ | | ------------------ | | | | 874| 7.70k|#define G_STMT_START do | | ------------------ | | 644| 7.70k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 7.70k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 7.70k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 7.70k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 7.70k| int _g_boolean_var_; \ | | | | | | 1018| 7.70k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 7.70k, False: 0] | | | | | | ------------------ | | | | | | 1019| 7.70k| _g_boolean_var_ = 1; \ | | | | | | 1020| 7.70k| else \ | | | | | | 1021| 7.70k| _g_boolean_var_ = 0; \ | | | | | | 1022| 7.70k| _g_boolean_var_; \ | | | | | | 1023| 7.70k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 7.70k, False: 0] | | | | ------------------ | | ------------------ | | 645| 7.70k| { } \ | | 646| 7.70k| else \ | | 647| 7.70k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 7.70k| } G_STMT_END | | ------------------ | | | | 882| 7.70k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 7.70k] | | | | ------------------ | | ------------------ ------------------ 585| | 586| | /* Fast path */ 587| 7.70k| if (src_type == dest_type) ------------------ | Branch (587:7): [True: 7.70k, False: 0] ------------------ 588| 7.70k| return TRUE; ------------------ | | 818| 7.70k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 7.70k|#define FALSE (0) | | ------------------ ------------------ 589| | 590| 0| return (g_type_is_a (src_type, dest_type) && ------------------ | Branch (590:11): [True: 0, False: 0] ------------------ 591| 0| g_type_value_table_peek (dest_type) == g_type_value_table_peek (src_type)); ------------------ | Branch (591:4): [True: 0, False: 0] ------------------ 592| 7.70k|} g_value_transform: 613| 3.85k|{ 614| 3.85k| GType dest_type; 615| | 616| 3.85k| g_return_val_if_fail (src_value, FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 617| 3.85k| g_return_val_if_fail (dest_value, FALSE); ------------------ | | 643| 3.85k| G_STMT_START { \ | | ------------------ | | | | 874| 3.85k|#define G_STMT_START do | | ------------------ | | 644| 3.85k| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 3.85k|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 3.85k| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 3.85k|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 3.85k| int _g_boolean_var_; \ | | | | | | 1018| 3.85k| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 3.85k, False: 0] | | | | | | ------------------ | | | | | | 1019| 3.85k| _g_boolean_var_ = 1; \ | | | | | | 1020| 3.85k| else \ | | | | | | 1021| 3.85k| _g_boolean_var_ = 0; \ | | | | | | 1022| 3.85k| _g_boolean_var_; \ | | | | | | 1023| 3.85k|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 3.85k, False: 0] | | | | ------------------ | | ------------------ | | 645| 3.85k| { } \ | | 646| 3.85k| else \ | | 647| 3.85k| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 3.85k| } G_STMT_END | | ------------------ | | | | 882| 3.85k|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 3.85k] | | | | ------------------ | | ------------------ ------------------ 618| | 619| 3.85k| dest_type = G_VALUE_TYPE (dest_value); ------------------ | | 59| 3.85k|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ 620| 3.85k| if (g_value_type_compatible (G_VALUE_TYPE (src_value), dest_type)) ------------------ | | 59| 3.85k|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ | Branch (620:7): [True: 3.85k, False: 0] ------------------ 621| 3.85k| { 622| 3.85k| g_value_copy (src_value, dest_value); 623| | 624| 3.85k| return TRUE; ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 625| 3.85k| } 626| 0| else 627| 0| { 628| 0| GValueTransform transform = transform_func_lookup (G_VALUE_TYPE (src_value), dest_type); ------------------ | | 59| 0|#define G_VALUE_TYPE(value) (((GValue*) (value))->g_type) ------------------ 629| | 630| 0| if (transform) ------------------ | Branch (630:11): [True: 0, False: 0] ------------------ 631| 0| { 632| 0| g_value_unset (dest_value); 633| | 634| | /* setup and transform */ 635| 0| value_meminit (dest_value, dest_type); 636| 0| transform (src_value, dest_value); 637| | 638| 0| return TRUE; ------------------ | | 818| 0|#define TRUE (!FALSE) | | ------------------ | | | | 814| 0|#define FALSE (0) | | ------------------ ------------------ 639| 0| } 640| 0| } 641| 0| return FALSE; ------------------ | | 814| 0|#define FALSE (0) ------------------ 642| 3.85k|} gvalue.c:transform_entries_cmp: 496| 4.02k|{ 497| 4.02k| const TransformEntry *e1 = bsearch_node1; 498| 4.02k| const TransformEntry *e2 = bsearch_node2; 499| 4.02k| gint cmp = G_BSEARCH_ARRAY_CMP (e1->src_type, e2->src_type); ------------------ | | 34| 4.02k|#define G_BSEARCH_ARRAY_CMP(v1,v2) ((v1) > (v2) ? +1 : (v1) == (v2) ? 0 : -1) | | ------------------ | | | Branch (34:37): [True: 1.78k, False: 2.24k] | | | Branch (34:56): [True: 1.32k, False: 924] | | ------------------ ------------------ 500| | 501| 4.02k| if (cmp) ------------------ | Branch (501:7): [True: 2.70k, False: 1.32k] ------------------ 502| 2.70k| return cmp; 503| 1.32k| else 504| 1.32k| return G_BSEARCH_ARRAY_CMP (e1->dest_type, e2->dest_type); ------------------ | | 34| 1.32k|#define G_BSEARCH_ARRAY_CMP(v1,v2) ((v1) > (v2) ? +1 : (v1) == (v2) ? 0 : -1) | | ------------------ | | | Branch (34:37): [True: 1.32k, False: 0] | | | Branch (34:56): [True: 0, False: 0] | | ------------------ ------------------ 505| 4.02k|} gvalue.c:value_meminit: 147| 7.70k|{ 148| 7.70k| value->g_type = value_type; 149| 7.70k| memset (value->data, 0, sizeof (value->data)); 150| 7.70k|} _g_value_transforms_init: 236| 2|{ 237| | /* some transformations are a bit questionable, 238| | * we currently skip those 239| | */ 240| 2|#define SKIP____register_transform_func(type1,type2,transform_func) /* skip questionable transforms */ \ 241| 2| (void)0 242| | 243| | /* numeric types (plus to string) */ 244| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_CHAR, value_transform_int_int); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_CHAR, value_transform_int_int); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_CHAR, value_transform_int_int); ------------------ | | 35| 2|#define value_transform_int_int value_transform_memcpy_data0 ------------------ 245| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_UCHAR, value_transform_int_u8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_UCHAR, value_transform_int_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 246| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_BOOLEAN, value_transform_int_bool); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_BOOLEAN, value_transform_int_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 247| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_INT, value_transform_int_int); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_INT, value_transform_int_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_INT, value_transform_int_int); ------------------ | | 35| 2|#define value_transform_int_int value_transform_memcpy_data0 ------------------ 248| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_UINT, value_transform_int_uint); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_UINT, value_transform_int_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 249| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_LONG, value_transform_int_long); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_LONG, value_transform_int_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 250| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_ULONG, value_transform_int_ulong); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_ULONG, value_transform_int_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 251| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_INT64, value_transform_int_int64); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_INT64, value_transform_int_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 252| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_UINT64, value_transform_int_uint64); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_UINT64, value_transform_int_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 253| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_ENUM, value_transform_int_long); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_ENUM, value_transform_int_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 254| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_FLAGS, value_transform_int_ulong); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_FLAGS, value_transform_int_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 255| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_FLOAT, value_transform_int_float); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_FLOAT, value_transform_int_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 256| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_DOUBLE, value_transform_int_double); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_DOUBLE, value_transform_int_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 257| 2| g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_STRING, value_transform_int_string); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_CHAR, G_TYPE_STRING, value_transform_int_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 258| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_CHAR, value_transform_uint_s8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_CHAR, value_transform_uint_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 259| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UCHAR, value_transform_uint_uint); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UCHAR, value_transform_uint_uint); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UCHAR, value_transform_uint_uint); ------------------ | | 36| 2|#define value_transform_uint_uint value_transform_memcpy_data0 ------------------ 260| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_BOOLEAN, value_transform_uint_bool); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_BOOLEAN, value_transform_uint_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 261| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_INT, value_transform_uint_int); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_INT, value_transform_uint_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 262| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UINT, value_transform_uint_uint); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UINT, value_transform_uint_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UINT, value_transform_uint_uint); ------------------ | | 36| 2|#define value_transform_uint_uint value_transform_memcpy_data0 ------------------ 263| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_LONG, value_transform_uint_long); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_LONG, value_transform_uint_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 264| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_ULONG, value_transform_uint_ulong); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_ULONG, value_transform_uint_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 265| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_INT64, value_transform_uint_int64); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_INT64, value_transform_uint_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 266| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UINT64, value_transform_uint_uint64); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_UINT64, value_transform_uint_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 267| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_ENUM, value_transform_uint_long); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_ENUM, value_transform_uint_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 268| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_FLAGS, value_transform_uint_ulong); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_FLAGS, value_transform_uint_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 269| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_FLOAT, value_transform_uint_float); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_FLOAT, value_transform_uint_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 270| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_DOUBLE, value_transform_uint_double); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_DOUBLE, value_transform_uint_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 271| 2| g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_STRING, value_transform_uint_string); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UCHAR, G_TYPE_STRING, value_transform_uint_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 272| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_CHAR, value_transform_int_s8); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_CHAR, value_transform_int_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 273| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_UCHAR, value_transform_int_u8); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_UCHAR, value_transform_int_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 274| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, value_transform_int_int); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, value_transform_int_int); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, value_transform_int_int); ------------------ | | 35| 2|#define value_transform_int_int value_transform_memcpy_data0 ------------------ 275| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_INT, value_transform_int_int); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_INT, value_transform_int_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_INT, value_transform_int_int); ------------------ | | 35| 2|#define value_transform_int_int value_transform_memcpy_data0 ------------------ 276| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_UINT, value_transform_int_uint); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_UINT, value_transform_int_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 277| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_LONG, value_transform_int_long); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_LONG, value_transform_int_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 278| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_ULONG, value_transform_int_ulong); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_ULONG, value_transform_int_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 279| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_INT64, value_transform_int_int64); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_INT64, value_transform_int_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 280| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_UINT64, value_transform_int_uint64); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_UINT64, value_transform_int_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 281| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_ENUM, value_transform_int_long); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_ENUM, value_transform_int_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 282| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_FLAGS, value_transform_int_ulong); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_FLAGS, value_transform_int_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 283| 2| SKIP____register_transform_func (G_TYPE_BOOLEAN, G_TYPE_FLOAT, value_transform_int_float); ------------------ | | 241| 2| (void)0 ------------------ 284| 2| SKIP____register_transform_func (G_TYPE_BOOLEAN, G_TYPE_DOUBLE, value_transform_int_double); ------------------ | | 241| 2| (void)0 ------------------ 285| 2| g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_STRING, value_transform_bool_string); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_BOOLEAN, G_TYPE_STRING, value_transform_bool_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 286| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_CHAR, value_transform_int_s8); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_CHAR, value_transform_int_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 287| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_UCHAR, value_transform_int_u8); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_UCHAR, value_transform_int_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 288| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_BOOLEAN, value_transform_int_bool); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_BOOLEAN, value_transform_int_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 289| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_INT, value_transform_int_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_INT, value_transform_int_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_INT, value_transform_int_int); ------------------ | | 35| 2|#define value_transform_int_int value_transform_memcpy_data0 ------------------ 290| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_UINT, value_transform_int_uint); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_UINT, value_transform_int_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 291| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_LONG, value_transform_int_long); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_LONG, value_transform_int_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 292| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_ULONG, value_transform_int_ulong); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_ULONG, value_transform_int_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 293| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_INT64, value_transform_int_int64); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_INT64, value_transform_int_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 294| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_UINT64, value_transform_int_uint64); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_UINT64, value_transform_int_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 295| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_ENUM, value_transform_int_long); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_ENUM, value_transform_int_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 296| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_FLAGS, value_transform_int_ulong); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_FLAGS, value_transform_int_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 297| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_FLOAT, value_transform_int_float); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_FLOAT, value_transform_int_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 298| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_DOUBLE, value_transform_int_double); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_DOUBLE, value_transform_int_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 299| 2| g_value_register_transform_func (G_TYPE_INT, G_TYPE_STRING, value_transform_int_string); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT, G_TYPE_STRING, value_transform_int_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 300| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_CHAR, value_transform_uint_s8); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_CHAR, value_transform_uint_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 301| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_UCHAR, value_transform_uint_u8); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_UCHAR, value_transform_uint_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 302| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_BOOLEAN, value_transform_uint_bool); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_BOOLEAN, value_transform_uint_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 303| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_INT, value_transform_uint_int); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_INT, value_transform_uint_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 304| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_UINT, value_transform_uint_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_UINT, value_transform_uint_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_UINT, value_transform_uint_uint); ------------------ | | 36| 2|#define value_transform_uint_uint value_transform_memcpy_data0 ------------------ 305| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_LONG, value_transform_uint_long); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_LONG, value_transform_uint_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 306| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_ULONG, value_transform_uint_ulong); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_ULONG, value_transform_uint_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 307| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_INT64, value_transform_uint_int64); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_INT64, value_transform_uint_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 308| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_UINT64, value_transform_uint_uint64); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_UINT64, value_transform_uint_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 309| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_ENUM, value_transform_uint_long); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_ENUM, value_transform_uint_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 310| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_FLAGS, value_transform_uint_ulong); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_FLAGS, value_transform_uint_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 311| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_FLOAT, value_transform_uint_float); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_FLOAT, value_transform_uint_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 312| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_DOUBLE, value_transform_uint_double); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_DOUBLE, value_transform_uint_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 313| 2| g_value_register_transform_func (G_TYPE_UINT, G_TYPE_STRING, value_transform_uint_string); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT, G_TYPE_STRING, value_transform_uint_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 314| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_CHAR, value_transform_long_s8); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_CHAR, value_transform_long_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 315| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_UCHAR, value_transform_long_u8); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_UCHAR, value_transform_long_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 316| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_BOOLEAN, value_transform_long_bool); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_BOOLEAN, value_transform_long_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 317| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_INT, value_transform_long_int); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_INT, value_transform_long_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 318| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_UINT, value_transform_long_uint); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_UINT, value_transform_long_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 319| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_LONG, value_transform_long_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_LONG, value_transform_long_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_LONG, value_transform_long_long); ------------------ | | 37| 2|#define value_transform_long_long value_transform_memcpy_data0 ------------------ 320| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_ULONG, value_transform_long_ulong); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_ULONG, value_transform_long_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 321| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_INT64, value_transform_long_int64); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_INT64, value_transform_long_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 322| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_UINT64, value_transform_long_uint64); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_UINT64, value_transform_long_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 323| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_ENUM, value_transform_long_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_ENUM, value_transform_long_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_ENUM, value_transform_long_long); ------------------ | | 37| 2|#define value_transform_long_long value_transform_memcpy_data0 ------------------ 324| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_FLAGS, value_transform_long_ulong); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_FLAGS, value_transform_long_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 325| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_FLOAT, value_transform_long_float); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_FLOAT, value_transform_long_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 326| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_DOUBLE, value_transform_long_double); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_DOUBLE, value_transform_long_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 327| 2| g_value_register_transform_func (G_TYPE_LONG, G_TYPE_STRING, value_transform_long_string); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_LONG, G_TYPE_STRING, value_transform_long_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 328| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_CHAR, value_transform_ulong_s8); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_CHAR, value_transform_ulong_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 329| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_UCHAR, value_transform_ulong_u8); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_UCHAR, value_transform_ulong_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 330| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_BOOLEAN, value_transform_ulong_bool); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_BOOLEAN, value_transform_ulong_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 331| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_INT, value_transform_ulong_int); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_INT, value_transform_ulong_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 332| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_UINT, value_transform_ulong_uint); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_UINT, value_transform_ulong_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 333| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_LONG, value_transform_ulong_long); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_LONG, value_transform_ulong_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 334| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_ULONG, value_transform_ulong_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_ULONG, value_transform_ulong_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_ULONG, value_transform_ulong_ulong); ------------------ | | 38| 2|#define value_transform_ulong_ulong value_transform_memcpy_data0 ------------------ 335| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_INT64, value_transform_ulong_int64); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_INT64, value_transform_ulong_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 336| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_UINT64, value_transform_ulong_uint64); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_UINT64, value_transform_ulong_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 337| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_ENUM, value_transform_ulong_long); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_ENUM, value_transform_ulong_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 338| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_FLAGS, value_transform_ulong_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_FLAGS, value_transform_ulong_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_FLAGS, value_transform_ulong_ulong); ------------------ | | 38| 2|#define value_transform_ulong_ulong value_transform_memcpy_data0 ------------------ 339| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_FLOAT, value_transform_ulong_float); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_FLOAT, value_transform_ulong_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 340| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_DOUBLE, value_transform_ulong_double); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_DOUBLE, value_transform_ulong_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 341| 2| g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_STRING, value_transform_ulong_string); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ULONG, G_TYPE_STRING, value_transform_ulong_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 342| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_CHAR, value_transform_int64_s8); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_CHAR, value_transform_int64_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 343| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_UCHAR, value_transform_int64_u8); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_UCHAR, value_transform_int64_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 344| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_BOOLEAN, value_transform_int64_bool); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_BOOLEAN, value_transform_int64_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 345| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_INT, value_transform_int64_int); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_INT, value_transform_int64_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 346| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_UINT, value_transform_int64_uint); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_UINT, value_transform_int64_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 347| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_LONG, value_transform_int64_long); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_LONG, value_transform_int64_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 348| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_ULONG, value_transform_int64_ulong); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_ULONG, value_transform_int64_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 349| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_INT64, value_transform_int64_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_INT64, value_transform_int64_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_INT64, value_transform_int64_int64); ------------------ | | 39| 2|#define value_transform_int64_int64 value_transform_memcpy_data0 ------------------ 350| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_UINT64, value_transform_int64_uint64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_UINT64, value_transform_int64_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 351| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_ENUM, value_transform_int64_long); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_ENUM, value_transform_int64_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 352| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_FLAGS, value_transform_int64_ulong); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_FLAGS, value_transform_int64_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 353| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_FLOAT, value_transform_int64_float); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_FLOAT, value_transform_int64_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 354| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_DOUBLE, value_transform_int64_double); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_DOUBLE, value_transform_int64_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 355| 2| g_value_register_transform_func (G_TYPE_INT64, G_TYPE_STRING, value_transform_int64_string); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_INT64, G_TYPE_STRING, value_transform_int64_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 356| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_CHAR, value_transform_uint64_s8); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_CHAR, value_transform_uint64_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 357| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_UCHAR, value_transform_uint64_u8); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_UCHAR, value_transform_uint64_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 358| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_BOOLEAN, value_transform_uint64_bool); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_BOOLEAN, value_transform_uint64_bool); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 359| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_INT, value_transform_uint64_int); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_INT, value_transform_uint64_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 360| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_UINT, value_transform_uint64_uint); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_UINT, value_transform_uint64_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 361| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_LONG, value_transform_uint64_long); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_LONG, value_transform_uint64_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 362| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_ULONG, value_transform_uint64_ulong); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_ULONG, value_transform_uint64_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 363| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_INT64, value_transform_uint64_int64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_INT64, value_transform_uint64_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 364| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_UINT64, value_transform_uint64_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_UINT64, value_transform_uint64_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_UINT64, value_transform_uint64_uint64); ------------------ | | 40| 2|#define value_transform_uint64_uint64 value_transform_memcpy_data0 ------------------ 365| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_ENUM, value_transform_uint64_long); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_ENUM, value_transform_uint64_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 366| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_FLAGS, value_transform_uint64_ulong); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_FLAGS, value_transform_uint64_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 367| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_FLOAT, value_transform_uint64_float); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_FLOAT, value_transform_uint64_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 368| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_DOUBLE, value_transform_uint64_double); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_DOUBLE, value_transform_uint64_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 369| 2| g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_STRING, value_transform_uint64_string); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_UINT64, G_TYPE_STRING, value_transform_uint64_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 370| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_CHAR, value_transform_long_s8); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_CHAR, value_transform_long_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 371| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_UCHAR, value_transform_long_u8); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_UCHAR, value_transform_long_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 372| 2| SKIP____register_transform_func (G_TYPE_ENUM, G_TYPE_BOOLEAN, value_transform_long_bool); ------------------ | | 241| 2| (void)0 ------------------ 373| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_INT, value_transform_long_int); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_INT, value_transform_long_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 374| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_UINT, value_transform_long_uint); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_UINT, value_transform_long_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 375| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_LONG, value_transform_long_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_LONG, value_transform_long_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_LONG, value_transform_long_long); ------------------ | | 37| 2|#define value_transform_long_long value_transform_memcpy_data0 ------------------ 376| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_ULONG, value_transform_long_ulong); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_ULONG, value_transform_long_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 377| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_INT64, value_transform_long_int64); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_INT64, value_transform_long_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 378| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_UINT64, value_transform_long_uint64); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_UINT64, value_transform_long_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 379| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_ENUM, value_transform_long_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_ENUM, value_transform_long_long); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_ENUM, value_transform_long_long); ------------------ | | 37| 2|#define value_transform_long_long value_transform_memcpy_data0 ------------------ 380| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_FLAGS, value_transform_long_ulong); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_FLAGS, value_transform_long_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 381| 2| SKIP____register_transform_func (G_TYPE_ENUM, G_TYPE_FLOAT, value_transform_long_float); ------------------ | | 241| 2| (void)0 ------------------ 382| 2| SKIP____register_transform_func (G_TYPE_ENUM, G_TYPE_DOUBLE, value_transform_long_double); ------------------ | | 241| 2| (void)0 ------------------ 383| 2| g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_STRING, value_transform_enum_string); ------------------ | | 130| 2|#define G_TYPE_ENUM G_TYPE_MAKE_FUNDAMENTAL (12) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_ENUM, G_TYPE_STRING, value_transform_enum_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 384| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_CHAR, value_transform_ulong_s8); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_CHAR, value_transform_ulong_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 385| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_UCHAR, value_transform_ulong_u8); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_UCHAR, value_transform_ulong_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 386| 2| SKIP____register_transform_func (G_TYPE_FLAGS, G_TYPE_BOOLEAN, value_transform_ulong_bool); ------------------ | | 241| 2| (void)0 ------------------ 387| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_INT, value_transform_ulong_int); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_INT, value_transform_ulong_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 388| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_UINT, value_transform_ulong_uint); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_UINT, value_transform_ulong_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 389| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_LONG, value_transform_ulong_long); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_LONG, value_transform_ulong_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 390| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_ULONG, value_transform_ulong_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_ULONG, value_transform_ulong_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_ULONG, value_transform_ulong_ulong); ------------------ | | 38| 2|#define value_transform_ulong_ulong value_transform_memcpy_data0 ------------------ 391| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_INT64, value_transform_ulong_int64); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_INT64, value_transform_ulong_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 392| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_UINT64, value_transform_ulong_uint64); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_UINT64, value_transform_ulong_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 393| 2| SKIP____register_transform_func (G_TYPE_FLAGS, G_TYPE_ENUM, value_transform_ulong_long); ------------------ | | 241| 2| (void)0 ------------------ 394| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_FLAGS, value_transform_ulong_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_FLAGS, value_transform_ulong_ulong); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_FLAGS, value_transform_ulong_ulong); ------------------ | | 38| 2|#define value_transform_ulong_ulong value_transform_memcpy_data0 ------------------ 395| 2| SKIP____register_transform_func (G_TYPE_FLAGS, G_TYPE_FLOAT, value_transform_ulong_float); ------------------ | | 241| 2| (void)0 ------------------ 396| 2| SKIP____register_transform_func (G_TYPE_FLAGS, G_TYPE_DOUBLE, value_transform_ulong_double); ------------------ | | 241| 2| (void)0 ------------------ 397| 2| g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_STRING, value_transform_flags_string); ------------------ | | 136| 2|#define G_TYPE_FLAGS G_TYPE_MAKE_FUNDAMENTAL (13) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLAGS, G_TYPE_STRING, value_transform_flags_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 398| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_CHAR, value_transform_float_s8); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_CHAR, value_transform_float_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 399| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_UCHAR, value_transform_float_u8); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_UCHAR, value_transform_float_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 400| 2| SKIP____register_transform_func (G_TYPE_FLOAT, G_TYPE_BOOLEAN, value_transform_float_bool); ------------------ | | 241| 2| (void)0 ------------------ 401| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_INT, value_transform_float_int); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_INT, value_transform_float_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 402| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_UINT, value_transform_float_uint); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_UINT, value_transform_float_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 403| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_LONG, value_transform_float_long); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_LONG, value_transform_float_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 404| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_ULONG, value_transform_float_ulong); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_ULONG, value_transform_float_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 405| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_INT64, value_transform_float_int64); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_INT64, value_transform_float_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 406| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_UINT64, value_transform_float_uint64); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_UINT64, value_transform_float_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 407| 2| SKIP____register_transform_func (G_TYPE_FLOAT, G_TYPE_ENUM, value_transform_float_long); ------------------ | | 241| 2| (void)0 ------------------ 408| 2| SKIP____register_transform_func (G_TYPE_FLOAT, G_TYPE_FLAGS, value_transform_float_ulong); ------------------ | | 241| 2| (void)0 ------------------ 409| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_FLOAT, value_transform_float_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_FLOAT, value_transform_float_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_FLOAT, value_transform_float_float); ------------------ | | 41| 2|#define value_transform_float_float value_transform_memcpy_data0 ------------------ 410| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_DOUBLE, value_transform_float_double); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_DOUBLE, value_transform_float_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 411| 2| g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_STRING, value_transform_float_string); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_FLOAT, G_TYPE_STRING, value_transform_float_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 412| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_CHAR, value_transform_double_s8); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_CHAR, value_transform_double_s8); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 413| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_UCHAR, value_transform_double_u8); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_UCHAR, value_transform_double_u8); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 414| 2| SKIP____register_transform_func (G_TYPE_DOUBLE, G_TYPE_BOOLEAN, value_transform_double_bool); ------------------ | | 241| 2| (void)0 ------------------ 415| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_INT, value_transform_double_int); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_INT, value_transform_double_int); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 416| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_UINT, value_transform_double_uint); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_UINT, value_transform_double_uint); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 417| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_LONG, value_transform_double_long); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_LONG, value_transform_double_long); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 418| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_ULONG, value_transform_double_ulong); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_ULONG, value_transform_double_ulong); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 419| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_INT64, value_transform_double_int64); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_INT64, value_transform_double_int64); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 420| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_UINT64, value_transform_double_uint64); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_UINT64, value_transform_double_uint64); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 421| 2| SKIP____register_transform_func (G_TYPE_DOUBLE, G_TYPE_ENUM, value_transform_double_long); ------------------ | | 241| 2| (void)0 ------------------ 422| 2| SKIP____register_transform_func (G_TYPE_DOUBLE, G_TYPE_FLAGS, value_transform_double_ulong); ------------------ | | 241| 2| (void)0 ------------------ 423| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_FLOAT, value_transform_double_float); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_FLOAT, value_transform_double_float); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 424| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_DOUBLE, value_transform_double_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_DOUBLE, value_transform_double_double); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_DOUBLE, value_transform_double_double); ------------------ | | 42| 2|#define value_transform_double_double value_transform_memcpy_data0 ------------------ 425| 2| g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_STRING, value_transform_double_string); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_DOUBLE, G_TYPE_STRING, value_transform_double_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 426| | /* string types */ 427| 2| g_value_register_transform_func (G_TYPE_STRING, G_TYPE_STRING, value_transform_string_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ g_value_register_transform_func (G_TYPE_STRING, G_TYPE_STRING, value_transform_string_string); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 428| 2|} _g_value_types_init: 423| 2|{ 424| 2| GTypeInfo info = { 425| 2| 0, /* class_size */ 426| 2| NULL, /* base_init */ 427| 2| NULL, /* base_destroy */ 428| 2| NULL, /* class_init */ 429| 2| NULL, /* class_destroy */ 430| 2| NULL, /* class_data */ 431| 2| 0, /* instance_size */ 432| 2| 0, /* n_preallocs */ 433| 2| NULL, /* instance_init */ 434| 2| NULL, /* value_table */ 435| 2| }; 436| 2| const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, }; 437| 2| GType type G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */; 438| | 439| | /* G_TYPE_CHAR / G_TYPE_UCHAR 440| | */ 441| 2| { 442| 2| static const GTypeValueTable value_table = { 443| 2| value_init_long0, /* value_init */ 444| 2| NULL, /* value_free */ 445| 2| value_copy_long0, /* value_copy */ 446| 2| NULL, /* value_peek_pointer */ 447| 2| "i", /* collect_format */ 448| 2| value_collect_int, /* collect_value */ 449| 2| "p", /* lcopy_format */ 450| 2| value_lcopy_char, /* lcopy_value */ 451| 2| }; 452| 2| info.value_table = &value_table; 453| 2| type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0); ------------------ | | 76| 2|#define G_TYPE_CHAR G_TYPE_MAKE_FUNDAMENTAL (3) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 454| 2| g_assert (type == G_TYPE_CHAR); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 455| 2| type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0); ------------------ | | 82| 2|#define G_TYPE_UCHAR G_TYPE_MAKE_FUNDAMENTAL (4) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 456| 2| g_assert (type == G_TYPE_UCHAR); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 457| 2| } 458| | 459| | /* G_TYPE_BOOLEAN 460| | */ 461| 2| { 462| 2| static const GTypeValueTable value_table = { 463| 2| value_init_long0, /* value_init */ 464| 2| NULL, /* value_free */ 465| 2| value_copy_long0, /* value_copy */ 466| 2| NULL, /* value_peek_pointer */ 467| 2| "i", /* collect_format */ 468| 2| value_collect_int, /* collect_value */ 469| 2| "p", /* lcopy_format */ 470| 2| value_lcopy_boolean, /* lcopy_value */ 471| 2| }; 472| 2| info.value_table = &value_table; 473| 2| type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0); ------------------ | | 88| 2|#define G_TYPE_BOOLEAN G_TYPE_MAKE_FUNDAMENTAL (5) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 474| 2| g_assert (type == G_TYPE_BOOLEAN); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 475| 2| } 476| | 477| | /* G_TYPE_INT / G_TYPE_UINT 478| | */ 479| 2| { 480| 2| static const GTypeValueTable value_table = { 481| 2| value_init_long0, /* value_init */ 482| 2| NULL, /* value_free */ 483| 2| value_copy_long0, /* value_copy */ 484| 2| NULL, /* value_peek_pointer */ 485| 2| "i", /* collect_format */ 486| 2| value_collect_int, /* collect_value */ 487| 2| "p", /* lcopy_format */ 488| 2| value_lcopy_int, /* lcopy_value */ 489| 2| }; 490| 2| info.value_table = &value_table; 491| 2| type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0); ------------------ | | 94| 2|#define G_TYPE_INT G_TYPE_MAKE_FUNDAMENTAL (6) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 492| 2| g_assert (type == G_TYPE_INT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 493| 2| type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0); ------------------ | | 100| 2|#define G_TYPE_UINT G_TYPE_MAKE_FUNDAMENTAL (7) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 494| 2| g_assert (type == G_TYPE_UINT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 495| 2| } 496| | 497| | /* G_TYPE_LONG / G_TYPE_ULONG 498| | */ 499| 2| { 500| 2| static const GTypeValueTable value_table = { 501| 2| value_init_long0, /* value_init */ 502| 2| NULL, /* value_free */ 503| 2| value_copy_long0, /* value_copy */ 504| 2| NULL, /* value_peek_pointer */ 505| 2| "l", /* collect_format */ 506| 2| value_collect_long, /* collect_value */ 507| 2| "p", /* lcopy_format */ 508| 2| value_lcopy_long, /* lcopy_value */ 509| 2| }; 510| 2| info.value_table = &value_table; 511| 2| type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0); ------------------ | | 106| 2|#define G_TYPE_LONG G_TYPE_MAKE_FUNDAMENTAL (8) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 512| 2| g_assert (type == G_TYPE_LONG); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 513| 2| type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0); ------------------ | | 112| 2|#define G_TYPE_ULONG G_TYPE_MAKE_FUNDAMENTAL (9) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 514| 2| g_assert (type == G_TYPE_ULONG); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 515| 2| } 516| | 517| | /* G_TYPE_INT64 / G_TYPE_UINT64 518| | */ 519| 2| { 520| 2| static const GTypeValueTable value_table = { 521| 2| value_init_int64, /* value_init */ 522| 2| NULL, /* value_free */ 523| 2| value_copy_int64, /* value_copy */ 524| 2| NULL, /* value_peek_pointer */ 525| 2| "q", /* collect_format */ 526| 2| value_collect_int64, /* collect_value */ 527| 2| "p", /* lcopy_format */ 528| 2| value_lcopy_int64, /* lcopy_value */ 529| 2| }; 530| 2| info.value_table = &value_table; 531| 2| type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0); ------------------ | | 118| 2|#define G_TYPE_INT64 G_TYPE_MAKE_FUNDAMENTAL (10) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 532| 2| g_assert (type == G_TYPE_INT64); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 533| 2| type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0); ------------------ | | 124| 2|#define G_TYPE_UINT64 G_TYPE_MAKE_FUNDAMENTAL (11) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 534| 2| g_assert (type == G_TYPE_UINT64); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 535| 2| } 536| | 537| | /* G_TYPE_FLOAT 538| | */ 539| 2| { 540| 2| static const GTypeValueTable value_table = { 541| 2| value_init_float, /* value_init */ 542| 2| NULL, /* value_free */ 543| 2| value_copy_float, /* value_copy */ 544| 2| NULL, /* value_peek_pointer */ 545| 2| "d", /* collect_format */ 546| 2| value_collect_float, /* collect_value */ 547| 2| "p", /* lcopy_format */ 548| 2| value_lcopy_float, /* lcopy_value */ 549| 2| }; 550| 2| info.value_table = &value_table; 551| 2| type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0); ------------------ | | 142| 2|#define G_TYPE_FLOAT G_TYPE_MAKE_FUNDAMENTAL (14) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 552| 2| g_assert (type == G_TYPE_FLOAT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 553| 2| } 554| | 555| | /* G_TYPE_DOUBLE 556| | */ 557| 2| { 558| 2| static const GTypeValueTable value_table = { 559| 2| value_init_double, /* value_init */ 560| 2| NULL, /* value_free */ 561| 2| value_copy_double, /* value_copy */ 562| 2| NULL, /* value_peek_pointer */ 563| 2| "d", /* collect_format */ 564| 2| value_collect_double, /* collect_value */ 565| 2| "p", /* lcopy_format */ 566| 2| value_lcopy_double, /* lcopy_value */ 567| 2| }; 568| 2| info.value_table = &value_table; 569| 2| type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0); ------------------ | | 148| 2|#define G_TYPE_DOUBLE G_TYPE_MAKE_FUNDAMENTAL (15) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 570| 2| g_assert (type == G_TYPE_DOUBLE); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 571| 2| } 572| | 573| | /* G_TYPE_STRING 574| | */ 575| 2| { 576| 2| static const GTypeValueTable value_table = { 577| 2| value_init_string, /* value_init */ 578| 2| value_free_string, /* value_free */ 579| 2| value_copy_string, /* value_copy */ 580| 2| value_peek_pointer0, /* value_peek_pointer */ 581| 2| "p", /* collect_format */ 582| 2| value_collect_string, /* collect_value */ 583| 2| "p", /* lcopy_format */ 584| 2| value_lcopy_string, /* lcopy_value */ 585| 2| }; 586| 2| info.value_table = &value_table; 587| 2| type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0); ------------------ | | 154| 2|#define G_TYPE_STRING G_TYPE_MAKE_FUNDAMENTAL (16) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 588| 2| g_assert (type == G_TYPE_STRING); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 589| 2| } 590| | 591| | /* G_TYPE_POINTER 592| | */ 593| 2| { 594| 2| static const GTypeValueTable value_table = { 595| 2| value_init_pointer, /* value_init */ 596| 2| NULL, /* value_free */ 597| 2| value_copy_pointer, /* value_copy */ 598| 2| value_peek_pointer0, /* value_peek_pointer */ 599| 2| "p", /* collect_format */ 600| 2| value_collect_pointer, /* collect_value */ 601| 2| "p", /* lcopy_format */ 602| 2| value_lcopy_pointer, /* lcopy_value */ 603| 2| }; 604| 2| info.value_table = &value_table; 605| 2| type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0); ------------------ | | 160| 2|#define G_TYPE_POINTER G_TYPE_MAKE_FUNDAMENTAL (17) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 606| 2| g_assert (type == G_TYPE_POINTER); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 607| 2| } 608| | 609| | /* G_TYPE_VARIANT 610| | */ 611| 2| { 612| 2| static const GTypeValueTable value_table = { 613| 2| value_init_pointer, /* value_init */ 614| 2| value_free_variant, /* value_free */ 615| 2| value_copy_variant, /* value_copy */ 616| 2| value_peek_pointer0, /* value_peek_pointer */ 617| 2| "p", /* collect_format */ 618| 2| value_collect_variant, /* collect_value */ 619| 2| "p", /* lcopy_format */ 620| 2| value_lcopy_variant, /* lcopy_value */ 621| 2| }; 622| 2| info.value_table = &value_table; 623| 2| type = g_type_register_fundamental (G_TYPE_VARIANT, g_intern_static_string ("GVariant"), &info, &finfo, 0); ------------------ | | 196| 2|#define G_TYPE_VARIANT G_TYPE_MAKE_FUNDAMENTAL (21) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 624| 2| g_assert (type == G_TYPE_VARIANT); ------------------ | | 231| 2|#define g_assert(expr) G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 232| 2| if G_LIKELY (expr) ; else \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:25): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 233| 2| g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 234| 0| #expr); \ | | 235| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 625| 2| } 626| 2|} g_pointer_type_register_static: 1450| 2|{ 1451| 2| const GTypeInfo type_info = { 1452| 2| 0, /* class_size */ 1453| 2| NULL, /* base_init */ 1454| 2| NULL, /* base_finalize */ 1455| 2| NULL, /* class_init */ 1456| 2| NULL, /* class_finalize */ 1457| 2| NULL, /* class_data */ 1458| 2| 0, /* instance_size */ 1459| 2| 0, /* n_preallocs */ 1460| 2| NULL, /* instance_init */ 1461| | NULL /* value_table */ 1462| 2| }; 1463| 2| GType type; 1464| | 1465| 2| g_return_val_if_fail (name != NULL, 0); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1466| 2| g_return_val_if_fail (g_type_from_name (name) == 0, 0); ------------------ | | 643| 2| G_STMT_START { \ | | ------------------ | | | | 874| 2|#define G_STMT_START do | | ------------------ | | 644| 2| if (G_LIKELY (expr)) \ | | ------------------ | | | | 1024| 2|#define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1)) | | | | ------------------ | | | | | | 1016| 2| G_GNUC_EXTENSION ({ \ | | | | | | ------------------ | | | | | | | | 54| 2|#define G_GNUC_EXTENSION __extension__ | | | | | | ------------------ | | | | | | 1017| 2| int _g_boolean_var_; \ | | | | | | 1018| 2| if (expr) \ | | | | | | ------------------ | | | | | | | Branch (1018:8): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 1019| 2| _g_boolean_var_ = 1; \ | | | | | | 1020| 2| else \ | | | | | | 1021| 2| _g_boolean_var_ = 0; \ | | | | | | 1022| 2| _g_boolean_var_; \ | | | | | | 1023| 2|}) | | | | ------------------ | | | | | Branch (1024:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 645| 2| { } \ | | 646| 2| else \ | | 647| 2| { \ | | 648| 0| g_return_if_fail_warning (G_LOG_DOMAIN, \ | | 649| 0| G_STRFUNC, \ | | ------------------ | | | | 784| 0|#define G_STRFUNC ((const char*) (__func__)) | | ------------------ | | 650| 0| #expr); \ | | 651| 0| return (val); \ | | 652| 0| } \ | | 653| 2| } G_STMT_END | | ------------------ | | | | 882| 2|#define G_STMT_END while (0) | | | | ------------------ | | | | | Branch (882:30): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 1467| | 1468| 2| type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0); ------------------ | | 160| 2|#define G_TYPE_POINTER G_TYPE_MAKE_FUNDAMENTAL (17) | | ------------------ | | | | 221| 2|#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT)) | | | | ------------------ | | | | | | 210| 2|#define G_TYPE_FUNDAMENTAL_SHIFT (2) | | | | ------------------ | | ------------------ ------------------ 1469| | 1470| 2| return type; 1471| 2|} fu_cbor_tag_to_string: 28| 101k|{ 29| 101k| if (val == FU_CBOR_TAG_POS_INT) ------------------ | Branch (29:9): [True: 57.6k, False: 43.6k] ------------------ 30| 57.6k| return "pos-int"; 31| 43.6k| if (val == FU_CBOR_TAG_NEG_INT) ------------------ | Branch (31:9): [True: 14.4k, False: 29.1k] ------------------ 32| 14.4k| return "neg-int"; 33| 29.1k| if (val == FU_CBOR_TAG_BYTES) ------------------ | Branch (33:9): [True: 3.04k, False: 26.1k] ------------------ 34| 3.04k| return "bytes"; 35| 26.1k| if (val == FU_CBOR_TAG_STRING) ------------------ | Branch (35:9): [True: 2.88k, False: 23.2k] ------------------ 36| 2.88k| return "string"; 37| 23.2k| if (val == FU_CBOR_TAG_ARRAY) ------------------ | Branch (37:9): [True: 4.05k, False: 19.1k] ------------------ 38| 4.05k| return "array"; 39| 19.1k| if (val == FU_CBOR_TAG_MAP) ------------------ | Branch (39:9): [True: 16.9k, False: 2.25k] ------------------ 40| 16.9k| return "map"; 41| 2.25k| if (val == FU_CBOR_TAG_SEMANTIC) ------------------ | Branch (41:9): [True: 12, False: 2.24k] ------------------ 42| 12| return "semantic"; 43| 2.24k| if (val == FU_CBOR_TAG_SPECIAL) ------------------ | Branch (43:9): [True: 2.24k, False: 0] ------------------ 44| 2.24k| return "special"; 45| 0| return NULL; 46| 2.24k|} fu_cbor_special_value_to_string: 59| 154|{ 60| 154| if (val == FU_CBOR_SPECIAL_VALUE_FALSE) ------------------ | Branch (60:9): [True: 1, False: 153] ------------------ 61| 1| return "false"; 62| 153| if (val == FU_CBOR_SPECIAL_VALUE_TRUE) ------------------ | Branch (62:9): [True: 1, False: 152] ------------------ 63| 1| return "true"; 64| 152| if (val == FU_CBOR_SPECIAL_VALUE_NULL) ------------------ | Branch (64:9): [True: 1, False: 151] ------------------ 65| 1| return "null"; 66| 151| if (val == FU_CBOR_SPECIAL_VALUE_UNDEFINED) ------------------ | Branch (66:9): [True: 1, False: 150] ------------------ 67| 1| return "undefined"; 68| 150| if (val == FU_CBOR_SPECIAL_VALUE_EXTENDED) ------------------ | Branch (68:9): [True: 1, False: 149] ------------------ 69| 1| return "extended"; 70| 149| if (val == FU_CBOR_SPECIAL_VALUE_FLOAT16) ------------------ | Branch (70:9): [True: 1, False: 148] ------------------ 71| 1| return "float16"; 72| 148| if (val == FU_CBOR_SPECIAL_VALUE_FLOAT32) ------------------ | Branch (72:9): [True: 1, False: 147] ------------------ 73| 1| return "float32"; 74| 147| if (val == FU_CBOR_SPECIAL_VALUE_FLOAT64) ------------------ | Branch (74:9): [True: 1, False: 146] ------------------ 75| 1| return "float64"; 76| 146| if (val == FU_CBOR_SPECIAL_VALUE_BREAK) ------------------ | Branch (76:9): [True: 1, False: 145] ------------------ 77| 1| return "break"; 78| 145| return NULL; 79| 146|} fu_cbor_item_kind_to_string: 91| 170|{ 92| 170| if (val == FU_CBOR_ITEM_KIND_INTEGER) ------------------ | Branch (92:9): [True: 31, False: 139] ------------------ 93| 31| return "integer"; 94| 139| if (val == FU_CBOR_ITEM_KIND_BYTES) ------------------ | Branch (94:9): [True: 15, False: 124] ------------------ 95| 15| return "bytes"; 96| 124| if (val == FU_CBOR_ITEM_KIND_STRING) ------------------ | Branch (96:9): [True: 75, False: 49] ------------------ 97| 75| return "string"; 98| 49| if (val == FU_CBOR_ITEM_KIND_ARRAY) ------------------ | Branch (98:9): [True: 13, False: 36] ------------------ 99| 13| return "array"; 100| 36| if (val == FU_CBOR_ITEM_KIND_MAP) ------------------ | Branch (100:9): [True: 25, False: 11] ------------------ 101| 25| return "map"; 102| 11| if (val == FU_CBOR_ITEM_KIND_BOOLEAN) ------------------ | Branch (102:9): [True: 11, False: 0] ------------------ 103| 11| return "boolean"; 104| 0| return NULL; 105| 11|} fu_coswid_tag_to_string: 28| 45.6k|{ 29| 45.6k| if (val == FU_COSWID_TAG_TAG_ID) ------------------ | Branch (29:9): [True: 7.60k, False: 38.0k] ------------------ 30| 7.60k| return "tag-id"; 31| 38.0k| if (val == FU_COSWID_TAG_SOFTWARE_NAME) ------------------ | Branch (31:9): [True: 425, False: 37.6k] ------------------ 32| 425| return "software-name"; 33| 37.6k| if (val == FU_COSWID_TAG_ENTITY) ------------------ | Branch (33:9): [True: 1.22k, False: 36.4k] ------------------ 34| 1.22k| return "entity"; 35| 36.4k| if (val == FU_COSWID_TAG_EVIDENCE) ------------------ | Branch (35:9): [True: 332, False: 36.1k] ------------------ 36| 332| return "evidence"; 37| 36.1k| if (val == FU_COSWID_TAG_LINK) ------------------ | Branch (37:9): [True: 1.81k, False: 34.3k] ------------------ 38| 1.81k| return "link"; 39| 34.3k| if (val == FU_COSWID_TAG_SOFTWARE_META) ------------------ | Branch (39:9): [True: 4.30k, False: 29.9k] ------------------ 40| 4.30k| return "software-meta"; 41| 29.9k| if (val == FU_COSWID_TAG_PAYLOAD) ------------------ | Branch (41:9): [True: 2.96k, False: 27.0k] ------------------ 42| 2.96k| return "payload"; 43| 27.0k| if (val == FU_COSWID_TAG_HASH) ------------------ | Branch (43:9): [True: 480, False: 26.5k] ------------------ 44| 480| return "hash"; 45| 26.5k| if (val == FU_COSWID_TAG_CORPUS) ------------------ | Branch (45:9): [True: 227, False: 26.3k] ------------------ 46| 227| return "corpus"; 47| 26.3k| if (val == FU_COSWID_TAG_PATCH) ------------------ | Branch (47:9): [True: 335, False: 25.9k] ------------------ 48| 335| return "patch"; 49| 25.9k| if (val == FU_COSWID_TAG_MEDIA) ------------------ | Branch (49:9): [True: 138, False: 25.8k] ------------------ 50| 138| return "media"; 51| 25.8k| if (val == FU_COSWID_TAG_SUPPLEMENTAL) ------------------ | Branch (51:9): [True: 339, False: 25.5k] ------------------ 52| 339| return "supplemental"; 53| 25.5k| if (val == FU_COSWID_TAG_TAG_VERSION) ------------------ | Branch (53:9): [True: 440, False: 25.0k] ------------------ 54| 440| return "tag-version"; 55| 25.0k| if (val == FU_COSWID_TAG_SOFTWARE_VERSION) ------------------ | Branch (55:9): [True: 198, False: 24.8k] ------------------ 56| 198| return "software-version"; 57| 24.8k| if (val == FU_COSWID_TAG_VERSION_SCHEME) ------------------ | Branch (57:9): [True: 402, False: 24.4k] ------------------ 58| 402| return "version-scheme"; 59| 24.4k| if (val == FU_COSWID_TAG_LANG) ------------------ | Branch (59:9): [True: 994, False: 23.4k] ------------------ 60| 994| return "lang"; 61| 23.4k| if (val == FU_COSWID_TAG_DIRECTORY) ------------------ | Branch (61:9): [True: 4.00k, False: 19.4k] ------------------ 62| 4.00k| return "directory"; 63| 19.4k| if (val == FU_COSWID_TAG_FILE) ------------------ | Branch (63:9): [True: 3.59k, False: 15.8k] ------------------ 64| 3.59k| return "file"; 65| 15.8k| if (val == FU_COSWID_TAG_PROCESS) ------------------ | Branch (65:9): [True: 283, False: 15.5k] ------------------ 66| 283| return "process"; 67| 15.5k| if (val == FU_COSWID_TAG_RESOURCE) ------------------ | Branch (67:9): [True: 442, False: 15.1k] ------------------ 68| 442| return "resource"; 69| 15.1k| if (val == FU_COSWID_TAG_SIZE) ------------------ | Branch (69:9): [True: 583, False: 14.5k] ------------------ 70| 583| return "size"; 71| 14.5k| if (val == FU_COSWID_TAG_FILE_VERSION) ------------------ | Branch (71:9): [True: 176, False: 14.3k] ------------------ 72| 176| return "file-version"; 73| 14.3k| if (val == FU_COSWID_TAG_KEY) ------------------ | Branch (73:9): [True: 335, False: 14.0k] ------------------ 74| 335| return "key"; 75| 14.0k| if (val == FU_COSWID_TAG_LOCATION) ------------------ | Branch (75:9): [True: 408, False: 13.6k] ------------------ 76| 408| return "location"; 77| 13.6k| if (val == FU_COSWID_TAG_FS_NAME) ------------------ | Branch (77:9): [True: 1.31k, False: 12.3k] ------------------ 78| 1.31k| return "fs-name"; 79| 12.3k| if (val == FU_COSWID_TAG_ROOT) ------------------ | Branch (79:9): [True: 34, False: 12.3k] ------------------ 80| 34| return "root"; 81| 12.3k| if (val == FU_COSWID_TAG_PATH_ELEMENTS) ------------------ | Branch (81:9): [True: 4.95k, False: 7.35k] ------------------ 82| 4.95k| return "path-elements"; 83| 7.35k| if (val == FU_COSWID_TAG_PROCESS_NAME) ------------------ | Branch (83:9): [True: 69, False: 7.28k] ------------------ 84| 69| return "process-name"; 85| 7.28k| if (val == FU_COSWID_TAG_PID) ------------------ | Branch (85:9): [True: 94, False: 7.18k] ------------------ 86| 94| return "pid"; 87| 7.18k| if (val == FU_COSWID_TAG_TYPE) ------------------ | Branch (87:9): [True: 217, False: 6.97k] ------------------ 88| 217| return "type"; 89| 6.97k| if (val == FU_COSWID_TAG_MISSING30) ------------------ | Branch (89:9): [True: 106, False: 6.86k] ------------------ 90| 106| return "missing30"; 91| 6.86k| if (val == FU_COSWID_TAG_ENTITY_NAME) ------------------ | Branch (91:9): [True: 99, False: 6.76k] ------------------ 92| 99| return "entity-name"; 93| 6.76k| if (val == FU_COSWID_TAG_REG_ID) ------------------ | Branch (93:9): [True: 74, False: 6.69k] ------------------ 94| 74| return "reg-id"; 95| 6.69k| if (val == FU_COSWID_TAG_ROLE) ------------------ | Branch (95:9): [True: 88, False: 6.60k] ------------------ 96| 88| return "role"; 97| 6.60k| if (val == FU_COSWID_TAG_THUMBPRINT) ------------------ | Branch (97:9): [True: 66, False: 6.53k] ------------------ 98| 66| return "thumbprint"; 99| 6.53k| if (val == FU_COSWID_TAG_DATE) ------------------ | Branch (99:9): [True: 80, False: 6.45k] ------------------ 100| 80| return "date"; 101| 6.45k| if (val == FU_COSWID_TAG_DEVICE_ID) ------------------ | Branch (101:9): [True: 71, False: 6.38k] ------------------ 102| 71| return "device-id"; 103| 6.38k| if (val == FU_COSWID_TAG_ARTIFACT) ------------------ | Branch (103:9): [True: 20, False: 6.36k] ------------------ 104| 20| return "artifact"; 105| 6.36k| if (val == FU_COSWID_TAG_HREF) ------------------ | Branch (105:9): [True: 83, False: 6.28k] ------------------ 106| 83| return "href"; 107| 6.28k| if (val == FU_COSWID_TAG_OWNERSHIP) ------------------ | Branch (107:9): [True: 35, False: 6.24k] ------------------ 108| 35| return "ownership"; 109| 6.24k| if (val == FU_COSWID_TAG_REL) ------------------ | Branch (109:9): [True: 70, False: 6.17k] ------------------ 110| 70| return "rel"; 111| 6.17k| if (val == FU_COSWID_TAG_MEDIA_TYPE) ------------------ | Branch (111:9): [True: 49, False: 6.12k] ------------------ 112| 49| return "media-type"; 113| 6.12k| if (val == FU_COSWID_TAG_USE) ------------------ | Branch (113:9): [True: 79, False: 6.05k] ------------------ 114| 79| return "use"; 115| 6.05k| if (val == FU_COSWID_TAG_ACTIVATION_STATUS) ------------------ | Branch (115:9): [True: 66, False: 5.98k] ------------------ 116| 66| return "activation-status"; 117| 5.98k| if (val == FU_COSWID_TAG_CHANNEL_TYPE) ------------------ | Branch (117:9): [True: 73, False: 5.91k] ------------------ 118| 73| return "channel-type"; 119| 5.91k| if (val == FU_COSWID_TAG_COLLOQUIAL_VERSION) ------------------ | Branch (119:9): [True: 48, False: 5.86k] ------------------ 120| 48| return "colloquial-version"; 121| 5.86k| if (val == FU_COSWID_TAG_DESCRIPTION) ------------------ | Branch (121:9): [True: 75, False: 5.78k] ------------------ 122| 75| return "description"; 123| 5.78k| if (val == FU_COSWID_TAG_EDITION) ------------------ | Branch (123:9): [True: 122, False: 5.66k] ------------------ 124| 122| return "edition"; 125| 5.66k| if (val == FU_COSWID_TAG_ENTITLEMENT_DATA_REQUIRED) ------------------ | Branch (125:9): [True: 220, False: 5.44k] ------------------ 126| 220| return "entitlement-data-required"; 127| 5.44k| if (val == FU_COSWID_TAG_ENTITLEMENT_KEY) ------------------ | Branch (127:9): [True: 114, False: 5.33k] ------------------ 128| 114| return "entitlement-key"; 129| 5.33k| if (val == FU_COSWID_TAG_GENERATOR) ------------------ | Branch (129:9): [True: 89, False: 5.24k] ------------------ 130| 89| return "generator"; 131| 5.24k| if (val == FU_COSWID_TAG_PERSISTENT_ID) ------------------ | Branch (131:9): [True: 71, False: 5.17k] ------------------ 132| 71| return "persistent-id"; 133| 5.17k| if (val == FU_COSWID_TAG_PRODUCT) ------------------ | Branch (133:9): [True: 38, False: 5.13k] ------------------ 134| 38| return "product"; 135| 5.13k| if (val == FU_COSWID_TAG_PRODUCT_FAMILY) ------------------ | Branch (135:9): [True: 88, False: 5.04k] ------------------ 136| 88| return "product-family"; 137| 5.04k| if (val == FU_COSWID_TAG_REVISION) ------------------ | Branch (137:9): [True: 45, False: 5.00k] ------------------ 138| 45| return "revision"; 139| 5.00k| if (val == FU_COSWID_TAG_SUMMARY) ------------------ | Branch (139:9): [True: 34, False: 4.96k] ------------------ 140| 34| return "summary"; 141| 4.96k| if (val == FU_COSWID_TAG_UNSPSC_CODE) ------------------ | Branch (141:9): [True: 77, False: 4.89k] ------------------ 142| 77| return "unspsc-code"; 143| 4.89k| if (val == FU_COSWID_TAG_UNSPSC_VERSION) ------------------ | Branch (143:9): [True: 71, False: 4.81k] ------------------ 144| 71| return "unspsc-version"; 145| 4.81k| return NULL; 146| 4.89k|} LLVMFuzzerTestOneInput: 15| 3.85k|{ 16| 3.85k| g_autoptr(GObject) object = g_object_new(FU_TYPE_WACOM_USB_FIRMWARE, NULL); ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ g_autoptr(GObject) object = g_object_new(FU_TYPE_WACOM_USB_FIRMWARE, NULL); ------------------ | | 11| 3.85k|#define FU_TYPE_COSWID_FIRMWARE (fu_coswid_firmware_get_type()) ------------------ 17| 3.85k| g_autoptr(GBytes) blob = g_bytes_new_static(data, size); ------------------ | | 1162| 3.85k|#define g_autoptr(TypeName) _GLIB_CLEANUP(_GLIB_AUTOPTR_FUNC_NAME(TypeName)) _GLIB_AUTOPTR_TYPENAME(TypeName) | | ------------------ | | | | 1129| 3.85k|#define _GLIB_CLEANUP(func) __attribute__((cleanup(func))) | | ------------------ ------------------ 18| | 19| 3.85k| (void)g_setenv("G_DEBUG", "fatal-criticals", TRUE); ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 20| 3.85k| (void)g_setenv("FWUPD_FUZZER_RUNNING", "1", TRUE); ------------------ | | 818| 3.85k|#define TRUE (!FALSE) | | ------------------ | | | | 814| 3.85k|#define FALSE (0) | | ------------------ ------------------ 21| | 22| | fu_fuzzer_test_input(FU_FUZZER(object), blob, NULL); 23| 3.85k| return 0; 24| 3.85k|} fu-cbor-item.c:g_autoptr_cleanup_generic_gfree: 26| 50.7k|{ 27| 50.7k| void **pp = (void**)p; 28| 50.7k| g_free (*pp); 29| 50.7k|} fu-cbor-common.c:g_autoptr_cleanup_generic_gfree: 26| 2.87k|{ 27| 2.87k| void **pp = (void**)p; 28| 2.87k| g_free (*pp); 29| 2.87k|} fu-coswid-firmware.c:g_autoptr_cleanup_generic_gfree: 26| 834|{ 27| 834| void **pp = (void**)p; 28| 834| g_free (*pp); 29| 834|} fu-fuzzer-firmware.c:glib_autoptr_cleanup_GObject: 1139| 3.85k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 3.85k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-fuzzer-firmware.c:glib_autoptr_clear_GObject: 1137| 3.85k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 3.85k, False: 0] ------------------ fu-fuzzer-firmware.c:glib_autoptr_cleanup_GBytes: 1139| 3.85k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 3.85k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-fuzzer-firmware.c:glib_autoptr_clear_GBytes: 1137| 3.85k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 3.85k, False: 0] ------------------ fwupd-common.c:glib_auto_cleanup_GStrv: 1160| 197| static G_GNUC_UNUSED inline void _GLIB_AUTO_FUNC_NAME(TypeName) (TypeName *_ptr) { if (*_ptr != none) (func) (*_ptr); } \ ------------------ | Branch (1160:90): [True: 88, False: 109] ------------------ fu-cbor-item.c:glib_autoptr_cleanup_GByteArray: 1139| 761| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 761|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-cbor-item.c:glib_autoptr_clear_GByteArray: 1137| 761| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 0, False: 761] ------------------ fu-cbor-common.c:glib_autoptr_cleanup_FuCborItem: 1139| 122k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 122k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-cbor-common.c:glib_autoptr_clear_FuCborItem: 1137| 122k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 97.9k, False: 24.7k] ------------------ fu-cbor-common.c:glib_autoptr_cleanup_GBytes: 1139| 3.03k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 3.03k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-cbor-common.c:glib_autoptr_clear_GBytes: 1137| 3.03k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 2.91k, False: 120] ------------------ fu-coswid-common.c:glib_autoptr_cleanup_GBytes: 1139| 401| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 401|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-coswid-common.c:glib_autoptr_clear_GBytes: 1137| 401| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 401, False: 0] ------------------ fu-coswid-common.c:glib_autoptr_cleanup_FuCborItem: 1139| 18.1k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 18.1k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-coswid-common.c:glib_autoptr_clear_FuCborItem: 1137| 18.1k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 18.1k, False: 0] ------------------ fu-coswid-firmware.c:glib_autoptr_cleanup_FuCborItem: 1139| 12.6k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 12.6k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-coswid-firmware.c:glib_autoptr_clear_FuCborItem: 1137| 12.6k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 11.4k, False: 1.21k] ------------------ fu-coswid-firmware.c:glib_autoptr_cleanup_FuCoswidFirmwareLink: 1139| 4.88k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 4.88k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-coswid-firmware.c:glib_autoptr_clear_FuCoswidFirmwareLink: 1137| 4.88k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 6, False: 4.87k] ------------------ fu-coswid-firmware.c:glib_autoptr_cleanup_FuCoswidFirmwarePayload: 1139| 2.12k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 2.12k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-coswid-firmware.c:glib_autoptr_clear_FuCoswidFirmwarePayload: 1137| 2.12k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 112, False: 2.01k] ------------------ fu-coswid-firmware.c:glib_autoptr_cleanup_FuCoswidFirmwareHash: 1139| 450| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 450|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-coswid-firmware.c:glib_autoptr_clear_FuCoswidFirmwareHash: 1137| 450| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 16, False: 434] ------------------ fu-coswid-firmware.c:glib_autoptr_cleanup_FuCoswidFirmwareEntity: 1139| 499| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 499|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-coswid-firmware.c:glib_autoptr_clear_FuCoswidFirmwareEntity: 1137| 499| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 416, False: 83] ------------------ fu-firmware.c:glib_autoptr_cleanup_GByteArray: 1139| 761| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 761|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-firmware.c:glib_autoptr_clear_GByteArray: 1137| 761| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 761, False: 0] ------------------ fu-firmware.c:glib_autoptr_cleanup_GBytes: 1139| 7.70k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 7.70k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-firmware.c:glib_autoptr_clear_GBytes: 1137| 7.70k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 761, False: 6.94k] ------------------ fu-firmware.c:glib_autoptr_cleanup_GInputStream: 1139| 11.5k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 11.5k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-firmware.c:glib_autoptr_clear_GInputStream: 1137| 11.5k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 11.5k, False: 0] ------------------ fu-input-stream.c:glib_autoptr_cleanup_GByteArray: 1139| 11.4k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 11.4k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-input-stream.c:glib_autoptr_clear_GByteArray: 1137| 11.4k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 2.79k, False: 8.61k] ------------------ fu-input-stream.c:glib_autoptr_cleanup_GError: 1139| 5.70k| { _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) (*_ptr); } \ ------------------ | | 1120| 5.70k|#define _GLIB_AUTOPTR_CLEAR_FUNC_NAME(TypeName) glib_autoptr_clear_##TypeName ------------------ fu-input-stream.c:glib_autoptr_clear_GError: 1137| 5.70k| { if (_ptr) (cleanup) ((ParentName *) _ptr); } \ ------------------ | Branch (1137:11): [True: 0, False: 5.70k] ------------------ fu-cbor-item.c:g_steal_pointer: 210| 51.5k|{ 211| 51.5k| gpointer *ptr = (gpointer *) pp; 212| 51.5k| gpointer ref; 213| | 214| 51.5k| ref = *ptr; 215| 51.5k| *ptr = NULL; 216| | 217| 51.5k| return ref; 218| 51.5k|} fu-cbor-common.c:g_steal_pointer: 210| 25.3k|{ 211| 25.3k| gpointer *ptr = (gpointer *) pp; 212| 25.3k| gpointer ref; 213| | 214| 25.3k| ref = *ptr; 215| 25.3k| *ptr = NULL; 216| | 217| 25.3k| return ref; 218| 25.3k|} fu-coswid-firmware.c:g_steal_pointer: 210| 7.40k|{ 211| 7.40k| gpointer *ptr = (gpointer *) pp; 212| 7.40k| gpointer ref; 213| | 214| 7.40k| ref = *ptr; 215| 7.40k| *ptr = NULL; 216| | 217| 7.40k| return ref; 218| 7.40k|} fu-input-stream.c:g_steal_pointer: 210| 8.55k|{ 211| 8.55k| gpointer *ptr = (gpointer *) pp; 212| 8.55k| gpointer ref; 213| | 214| 8.55k| ref = *ptr; 215| 8.55k| *ptr = NULL; 216| | 217| 8.55k| return ref; 218| 8.55k|} fu-common.c:_GLIB_CHECKED_ADD_U64: 462| 233k|static inline gboolean _GLIB_CHECKED_ADD_U64 (guint64 *dest, guint64 a, guint64 b) { 463| 233k| G_STATIC_ASSERT(sizeof (unsigned long long) == sizeof (guint64)); ------------------ | | 758| 233k|#define G_STATIC_ASSERT(expr) _Static_assert (expr, "Expression evaluates to false") ------------------ 464| 233k| return !__builtin_uaddll_overflow(a, b, (unsigned long long *) dest); } fu-fuzzer-firmware.c:FU_FUZZER: 1580| 3.85k| G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { \ 1581| 3.85k| return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } \ ------------------ | | 484| 3.85k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | ------------------ | | | | 2300| 3.85k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | ------------------ ------------------ fu-coswid-firmware.c:fu_coswid_firmware_get_type_once: 1762| 1|#define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2035| 1| _G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER(TypeName, type_name, TYPE_PARENT, flags) \ | | ------------------ | | | | 2013| 1|type_name##_get_type_once (void) \ | | | | 2014| 1|{ \ | | | | 2015| 1| GType g_define_type_id = \ | | | | 2016| 1| g_type_register_static_simple (TYPE_PARENT, \ | | | | 2017| 1| g_intern_static_string (#TypeName), \ | | | | 2018| 1| sizeof (TypeName##Class), \ | | | | 2019| 1| (GClassInitFunc)(void (*)(void)) type_name##_class_intern_init, \ | | | | 2020| 1| sizeof (TypeName), \ | | | | 2021| 1| (GInstanceInitFunc)(void (*)(void)) type_name##_init, \ | | | | 2022| 1| (GTypeFlags) flags); \ | | | | 2023| 1| { /* custom code follows */ | | ------------------ ------------------ #define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2026| 1| } \ | | 2027| 1| return g_define_type_id; \ | | 2028| 1|} /* closes type_name##_get_type_once() */ ------------------ fu-coswid-firmware.c:fu_coswid_firmware_class_intern_init: 1960| 1|static void type_name##_class_intern_init (gpointer klass) \ 1961| 1|{ \ 1962| 1| type_name##_parent_class = g_type_class_peek_parent (klass); \ 1963| 1| if (TypeName##_private_offset != 0) \ ------------------ | Branch (1963:7): [True: 1, False: 0] ------------------ 1964| 1| g_type_class_adjust_private_offset (klass, &TypeName##_private_offset); \ 1965| 1| type_name##_class_init ((TypeName##Class*) klass); \ 1966| 1|} fu-coswid-firmware.c:FU_FIRMWARE_CLASS: 1504| 1| G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_CLASS (gpointer ptr) { \ 1505| 1| return G_TYPE_CHECK_CLASS_CAST (ptr, module_obj_name##_get_type (), ModuleObjName##Class); } \ ------------------ | | 553| 1|#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type)) | | ------------------ | | | | 2302| 1| ((ct*) g_type_check_class_cast ((GTypeClass*) cp, gt)) | | ------------------ ------------------ fu-coswid-firmware.c:FU_COSWID_FIRMWARE: 1502| 19.4k| G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { \ 1503| 19.4k| return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } \ ------------------ | | 484| 19.4k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | ------------------ | | | | 2300| 19.4k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | ------------------ ------------------ fu-coswid-firmware.c:fu_coswid_firmware_get_instance_private: 1990| 20.5k|type_name##_get_instance_private (TypeName *self) \ 1991| 20.5k|{ \ 1992| 20.5k| return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); \ ------------------ | | 860| 20.5k| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1993| 20.5k|} \ fu-coswid-firmware.c:FU_FIRMWARE: 1502| 7.70k| G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { \ 1503| 7.70k| return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } \ ------------------ | | 484| 7.70k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | ------------------ | | | | 2300| 7.70k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | ------------------ ------------------ fu-firmware.c:fu_firmware_get_type_once: 1762| 1|#define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2035| 1| _G_DEFINE_TYPE_EXTENDED_BEGIN_REGISTER(TypeName, type_name, TYPE_PARENT, flags) \ | | ------------------ | | | | 2013| 1|type_name##_get_type_once (void) \ | | | | 2014| 1|{ \ | | | | 2015| 1| GType g_define_type_id = \ | | | | 2016| 1| g_type_register_static_simple (TYPE_PARENT, \ | | | | 2017| 1| g_intern_static_string (#TypeName), \ | | | | 2018| 1| sizeof (TypeName##Class), \ | | | | 2019| 1| (GClassInitFunc)(void (*)(void)) type_name##_class_intern_init, \ | | | | 2020| 1| sizeof (TypeName), \ | | | | 2021| 1| (GInstanceInitFunc)(void (*)(void)) type_name##_init, \ | | | | 2022| 1| (GTypeFlags) flags); \ | | | | 2023| 1| { /* custom code follows */ | | ------------------ ------------------ #define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END() ------------------ | | 2026| 1| } \ | | 2027| 1| return g_define_type_id; \ | | 2028| 1|} /* closes type_name##_get_type_once() */ ------------------ fu-firmware.c:fu_firmware_class_intern_init: 1960| 1|static void type_name##_class_intern_init (gpointer klass) \ 1961| 1|{ \ 1962| 1| type_name##_parent_class = g_type_class_peek_parent (klass); \ 1963| 1| if (TypeName##_private_offset != 0) \ ------------------ | Branch (1963:7): [True: 1, False: 0] ------------------ 1964| 1| g_type_class_adjust_private_offset (klass, &TypeName##_private_offset); \ 1965| 1| type_name##_class_init ((TypeName##Class*) klass); \ 1966| 1|} fu-firmware.c:fu_firmware_get_instance_private: 1990| 47.4k|type_name##_get_instance_private (TypeName *self) \ 1991| 47.4k|{ \ 1992| 47.4k| return (G_STRUCT_MEMBER_P (self, TypeName##_private_offset)); \ ------------------ | | 860| 47.4k| ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset))) ------------------ 1993| 47.4k|} \ fu-firmware.c:FU_IS_FIRMWARE: 1506| 40.5k| G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) { \ 1507| 40.5k| return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); } \ ------------------ | | 497| 40.5k|#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type) (_G_TYPE_CIT ((instance), (g_type))) | | ------------------ | | | | 2313| 40.5k|# define _G_TYPE_CIT(ip, gt) (G_GNUC_EXTENSION ({ \ | | | | ------------------ | | | | | | 54| 40.5k|#define G_GNUC_EXTENSION __extension__ | | | | ------------------ | | | | 2314| 40.5k| GTypeInstance *__inst = (GTypeInstance*) ip; GType __t = gt; gboolean __r; \ | | | | 2315| 40.5k| if (!__inst) \ | | | | ------------------ | | | | | Branch (2315:7): [True: 0, False: 40.5k] | | | | ------------------ | | | | 2316| 40.5k| __r = FALSE; \ | | | | ------------------ | | | | | | 814| 0|#define FALSE (0) | | | | ------------------ | | | | 2317| 40.5k| else if (__inst->g_class && __inst->g_class->g_type == __t) \ | | | | ------------------ | | | | | Branch (2317:12): [True: 40.5k, False: 0] | | | | | Branch (2317:31): [True: 0, False: 40.5k] | | | | ------------------ | | | | 2318| 40.5k| __r = TRUE; \ | | | | ------------------ | | | | | | 818| 0|#define TRUE (!FALSE) | | | | | | ------------------ | | | | | | | | 814| 0|#define FALSE (0) | | | | | | ------------------ | | | | ------------------ | | | | 2319| 40.5k| else \ | | | | 2320| 40.5k| __r = g_type_check_instance_is_a (__inst, __t); \ | | | | 2321| 40.5k| __r; \ | | | | 2322| 40.5k|})) | | ------------------ ------------------ fu-firmware.c:FU_FIRMWARE_GET_CLASS: 1510| 12.3k| G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_GET_CLASS (gpointer ptr) { \ 1511| 12.3k| return G_TYPE_INSTANCE_GET_CLASS (ptr, module_obj_name##_get_type (), ModuleObjName##Class); } \ ------------------ | | 527| 12.3k|#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), (g_type), c_type)) | | ------------------ | | | | 2309| 12.3k|#define _G_TYPE_IGC(ip, gt, ct) ((ct*) (((GTypeInstance*) ip)->g_class)) | | ------------------ ------------------ fu-firmware.c:FU_FIRMWARE: 1502| 15.4k| G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) { \ 1503| 15.4k| return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); } \ ------------------ | | 484| 15.4k|#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type)) | | ------------------ | | | | 2300| 15.4k| ((ct*) g_type_check_instance_cast ((GTypeInstance*) ip, gt)) | | ------------------ ------------------ fu-fuzzer.c:FU_FUZZER_GET_IFACE: 1584| 3.85k| G_GNUC_UNUSED static inline ModuleObjName##Interface * MODULE##_##OBJ_NAME##_GET_IFACE (gpointer ptr) { \ 1585| 3.85k| return G_TYPE_INSTANCE_GET_INTERFACE (ptr, module_obj_name##_get_type (), ModuleObjName##Interface); } \ ------------------ | | 540| 3.85k|#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type)) | | ------------------ | | | | 2310| 3.85k|#define _G_TYPE_IGI(ip, gt, ct) ((ct*) g_type_interface_peek (((GTypeInstance*) ip)->g_class, gt)) | | ------------------ ------------------