igraph_dl_yylex: 1151| 10.4M|{ 1152| 10.4M| yy_state_type yy_current_state; 1153| 10.4M| char *yy_cp, *yy_bp; 1154| 10.4M| int yy_act; 1155| 10.4M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1156| | 1157| 10.4M| yylval = yylval_param; ------------------ | | 964| 10.4M| # define yylval yyg->yylval_r ------------------ 1158| | 1159| 10.4M| yylloc = yylloc_param; ------------------ | | 966| 10.4M| # define yylloc yyg->yylloc_r ------------------ 1160| | 1161| 10.4M| if ( !yyg->yy_init ) ------------------ | Branch (1161:7): [True: 2.32k, False: 10.4M] ------------------ 1162| 2.32k| { 1163| 2.32k| yyg->yy_init = 1; 1164| | 1165| |#ifdef YY_USER_INIT 1166| | YY_USER_INIT; 1167| |#endif 1168| | 1169| 2.32k| if ( ! yyg->yy_start ) ------------------ | Branch (1169:8): [True: 2.32k, False: 0] ------------------ 1170| 2.32k| yyg->yy_start = 1; /* first start state */ 1171| | 1172| 2.32k| if ( ! yyin ) ------------------ | | 356| 2.32k|#define yyin yyg->yyin_r ------------------ | Branch (1172:8): [True: 0, False: 2.32k] ------------------ 1173| 0| yyin = stdin; ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 1174| | 1175| 2.32k| if ( ! yyout ) ------------------ | | 357| 2.32k|#define yyout yyg->yyout_r ------------------ | Branch (1175:8): [True: 2.32k, False: 0] ------------------ 1176| 2.32k| yyout = stdout; ------------------ | | 357| 2.32k|#define yyout yyg->yyout_r ------------------ 1177| | 1178| 2.32k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 521| 2.32k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 0, False: 2.32k] | | ------------------ | | 522| 2.32k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.32k| : NULL) ------------------ | Branch (1178:8): [True: 2.32k, False: 0] ------------------ 1179| 2.32k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 2.32k|#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack ------------------ 1180| 2.32k| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 527| 2.32k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1181| 2.32k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 2.32k|#define yy_create_buffer igraph_dl_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 2.32k|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 2.32k|#define YY_BUF_SIZE 16384 ------------------ 1182| 2.32k| } 1183| | 1184| 2.32k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.32k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1185| 2.32k| } 1186| | 1187| 10.4M| { 1188| 10.4M|#line 80 "/src/igraph/src/io/dl-lexer.l" 1189| | 1190| | 1191| 10.4M|#line 1192 "/src/igraph/build/src/io/parsers/dl-lexer.c" 1192| | 1193| 17.2M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1193:23): [True: 17.2M, Folded] ------------------ 1194| 17.2M| { 1195| 17.2M| yy_cp = yyg->yy_c_buf_p; 1196| | 1197| | /* Support of yytext. */ 1198| 17.2M| *yy_cp = yyg->yy_hold_char; 1199| | 1200| | /* yy_bp points to the position in yy_ch_buf of the start of 1201| | * the current run. 1202| | */ 1203| 17.2M| yy_bp = yy_cp; 1204| | 1205| 17.2M| yy_current_state = yyg->yy_start; 1206| 17.2M|yy_match: 1207| 17.2M| do 1208| 51.6M| { 1209| 51.6M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 51.6M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1210| 51.6M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1210:9): [True: 46.3M, False: 5.24M] ------------------ 1211| 46.3M| { 1212| 46.3M| yyg->yy_last_accepting_state = yy_current_state; 1213| 46.3M| yyg->yy_last_accepting_cpos = yy_cp; 1214| 46.3M| } 1215| 84.0M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1215:12): [True: 32.4M, False: 51.6M] ------------------ 1216| 32.4M| { 1217| 32.4M| yy_current_state = (int) yy_def[yy_current_state]; 1218| 32.4M| if ( yy_current_state >= 129 ) ------------------ | Branch (1218:10): [True: 17.7M, False: 14.7M] ------------------ 1219| 17.7M| yy_c = yy_meta[yy_c]; 1220| 32.4M| } 1221| 51.6M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1222| 51.6M| ++yy_cp; 1223| 51.6M| } 1224| 51.6M| while ( yy_base[yy_current_state] != 493 ); ------------------ | Branch (1224:11): [True: 34.3M, False: 17.2M] ------------------ 1225| | 1226| 17.2M|yy_find_action: 1227| 17.2M| yy_act = yy_accept[yy_current_state]; 1228| 17.2M| if ( yy_act == 0 ) ------------------ | Branch (1228:8): [True: 14.3M, False: 2.92M] ------------------ 1229| 14.3M| { /* have to back up */ 1230| 14.3M| yy_cp = yyg->yy_last_accepting_cpos; 1231| 14.3M| yy_current_state = yyg->yy_last_accepting_state; 1232| 14.3M| yy_act = yy_accept[yy_current_state]; 1233| 14.3M| } 1234| | 1235| 17.2M| YY_DO_BEFORE_ACTION; ------------------ | | 588| 17.2M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 577| 17.2M|#define yytext_ptr yytext_r | | ------------------ | | 589| 17.2M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 17.2M|#define yyleng yyg->yyleng_r | | ------------------ | | 590| 17.2M| yyg->yy_hold_char = *yy_cp; \ | | 591| 17.2M| *yy_cp = '\0'; \ | | 592| 17.2M| yyg->yy_c_buf_p = yy_cp; ------------------ 1236| | 1237| 17.2M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 594| 34.5M|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1237:8): [True: 17.2M, False: 11.6k] | Branch (1237:38): [True: 2.52M, False: 14.7M] ------------------ 1238| 2.52M| { 1239| 2.52M| int yyl; 1240| 5.04M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 359| 5.04M|#define yyleng yyg->yyleng_r ------------------ | Branch (1240:19): [True: 2.52M, False: 2.52M] ------------------ 1241| 2.52M| if ( yytext[yyl] == '\n' ) ------------------ | | 360| 2.52M|#define yytext yyg->yytext_r ------------------ | Branch (1241:10): [True: 2.52M, False: 1.24k] ------------------ 1242| | 1243| 2.52M| do{ yylineno++; ------------------ | | 361| 2.52M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 527| 2.52M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1244| 2.52M| yycolumn=0; ------------------ | | 362| 2.52M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 527| 2.52M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1245| 2.52M| }while(0) ------------------ | Branch (1245:12): [Folded, False: 2.52M] ------------------ 1246| 2.52M|; 1247| 2.52M| } 1248| | 1249| 17.2M|do_action: /* This label is used only to access EOF actions. */ 1250| | 1251| 17.2M| switch ( yy_act ) 1252| 17.2M| { /* beginning of action switch */ 1253| 0| case 0: /* must back up */ ------------------ | Branch (1253:4): [True: 0, False: 17.2M] ------------------ 1254| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1255| 0| *yy_cp = yyg->yy_hold_char; 1256| 0| yy_cp = yyg->yy_last_accepting_cpos; 1257| 0| yy_current_state = yyg->yy_last_accepting_state; 1258| 0| goto yy_find_action; 1259| | 1260| 2.52M|case 1: ------------------ | Branch (1260:1): [True: 2.52M, False: 14.7M] ------------------ 1261| |/* rule 1 can match eol */ 1262| 2.52M|YY_RULE_SETUP ------------------ | | 1146| 2.52M| YY_USER_ACTION | | ------------------ | | | | 890| 2.52M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.52M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.52M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.52M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1263| 2.52M|#line 82 "/src/igraph/src/io/dl-lexer.l" 1264| 2.52M|{ return NEWLINE; } 1265| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1266| 2.15k|case 2: ------------------ | Branch (1266:1): [True: 2.15k, False: 17.2M] ------------------ 1267| 2.15k|YY_RULE_SETUP ------------------ | | 1146| 2.15k| YY_USER_ACTION | | ------------------ | | | | 890| 2.15k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.15k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.15k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1268| 2.15k|#line 84 "/src/igraph/src/io/dl-lexer.l" 1269| 2.15k|{ return DL; } 1270| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1271| 2.15k|case 3: ------------------ | Branch (1271:1): [True: 2.15k, False: 17.2M] ------------------ 1272| 2.15k|YY_RULE_SETUP ------------------ | | 1146| 2.15k| YY_USER_ACTION | | ------------------ | | | | 890| 2.15k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.15k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.15k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1273| 2.15k|#line 85 "/src/igraph/src/io/dl-lexer.l" 1274| 2.15k|{ return NEQ; } 1275| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1276| 2.16k|case 4: ------------------ | Branch (1276:1): [True: 2.16k, False: 17.2M] ------------------ 1277| 2.16k|YY_RULE_SETUP ------------------ | | 1146| 2.16k| YY_USER_ACTION | | ------------------ | | | | 890| 2.16k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.16k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.16k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1278| 2.16k|#line 86 "/src/igraph/src/io/dl-lexer.l" 1279| 2.16k|{ return NUM; } 1280| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1281| 1.99k|case 5: ------------------ | Branch (1281:1): [True: 1.99k, False: 17.2M] ------------------ 1282| 1.99k|YY_RULE_SETUP ------------------ | | 1146| 1.99k| YY_USER_ACTION | | ------------------ | | | | 890| 1.99k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.99k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.99k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.99k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1283| 1.99k|#line 88 "/src/igraph/src/io/dl-lexer.l" 1284| 1.99k|{ 1285| 1.99k| switch (yyextra->mode) { ------------------ | | 358| 1.99k|#define yyextra yyg->yyextra_r ------------------ | Branch (1285:11): [True: 1.99k, False: 0] ------------------ 1286| 494| case 0: BEGIN(FULLMATRIX); ------------------ | | 369| 494|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 0: BEGIN(FULLMATRIX); ------------------ | | 906| 494|#define FULLMATRIX 2 ------------------ | Branch (1286:3): [True: 494, False: 1.49k] ------------------ 1287| 494| break; 1288| 983| case 1: BEGIN(EDGELIST); ------------------ | | 369| 983|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 1: BEGIN(EDGELIST); ------------------ | | 907| 983|#define EDGELIST 3 ------------------ | Branch (1288:3): [True: 983, False: 1.00k] ------------------ 1289| 983| break; 1290| 514| case 2: BEGIN(NODELIST); ------------------ | | 369| 514|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 2: BEGIN(NODELIST); ------------------ | | 908| 514|#define NODELIST 4 ------------------ | Branch (1290:3): [True: 514, False: 1.47k] ------------------ 1291| 514| break; 1292| 1.99k| } 1293| 1.99k| return DATA; } 1294| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1295| 336|case 6: ------------------ | Branch (1295:1): [True: 336, False: 17.2M] ------------------ 1296| 336|YY_RULE_SETUP ------------------ | | 1146| 336| YY_USER_ACTION | | ------------------ | | | | 890| 336|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 336| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 336|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 336|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1297| 336|#line 99 "/src/igraph/src/io/dl-lexer.l" 1298| 336|{ BEGIN(LABELM); return LABELS; } ------------------ | | 369| 336|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(LABELM); return LABELS; } ------------------ | | 905| 336|#define LABELM 1 ------------------ 1299| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1300| 386|case 7: ------------------ | Branch (1300:1): [True: 386, False: 17.2M] ------------------ 1301| 386|YY_RULE_SETUP ------------------ | | 1146| 386| YY_USER_ACTION | | ------------------ | | | | 890| 386|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 386| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 386|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 386|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1302| 386|#line 100 "/src/igraph/src/io/dl-lexer.l" 1303| 386|{ 1304| 386| return LABELSEMBEDDED; } 1305| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1306| 4|case 8: ------------------ | Branch (1306:1): [True: 4, False: 17.2M] ------------------ 1307| 4|YY_RULE_SETUP ------------------ | | 1146| 4| YY_USER_ACTION | | ------------------ | | | | 890| 4|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 4|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 4|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1308| 4|#line 102 "/src/igraph/src/io/dl-lexer.l" 1309| 4|{ 1310| 4| yyextra->mode=0; return FORMATFULLMATRIX; } ------------------ | | 358| 4|#define yyextra yyg->yyextra_r ------------------ 1311| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1312| 1.01k|case 9: ------------------ | Branch (1312:1): [True: 1.01k, False: 17.2M] ------------------ 1313| 1.01k|YY_RULE_SETUP ------------------ | | 1146| 1.01k| YY_USER_ACTION | | ------------------ | | | | 890| 1.01k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.01k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.01k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1314| 1.01k|#line 104 "/src/igraph/src/io/dl-lexer.l" 1315| 1.01k|{ 1316| 1.01k| yyextra->mode=1; return FORMATEDGELIST1; } ------------------ | | 358| 1.01k|#define yyextra yyg->yyextra_r ------------------ 1317| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1318| 528|case 10: ------------------ | Branch (1318:1): [True: 528, False: 17.2M] ------------------ 1319| 528|YY_RULE_SETUP ------------------ | | 1146| 528| YY_USER_ACTION | | ------------------ | | | | 890| 528|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 528| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 528|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 528|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1320| 528|#line 106 "/src/igraph/src/io/dl-lexer.l" 1321| 528|{ 1322| 528| yyextra->mode=2; return FORMATNODELIST1; } ------------------ | | 358| 528|#define yyextra yyg->yyextra_r ------------------ 1323| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1324| 6.78k|case 11: ------------------ | Branch (1324:1): [True: 6.78k, False: 17.2M] ------------------ 1325| 6.78k|YY_RULE_SETUP ------------------ | | 1146| 6.78k| YY_USER_ACTION | | ------------------ | | | | 890| 6.78k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 6.78k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 6.78k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 6.78k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1326| 6.78k|#line 109 "/src/igraph/src/io/dl-lexer.l" 1327| 6.78k|{ /* eaten up */ } 1328| 6.78k| YY_BREAK ------------------ | | 1142| 6.78k|#define YY_BREAK /*LINTED*/break; ------------------ 1329| 1.63M|case 12: ------------------ | Branch (1329:1): [True: 1.63M, False: 15.6M] ------------------ 1330| 1.63M|YY_RULE_SETUP ------------------ | | 1146| 1.63M| YY_USER_ACTION | | ------------------ | | | | 890| 1.63M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.63M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.63M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.63M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1331| 1.63M|#line 110 "/src/igraph/src/io/dl-lexer.l" 1332| 1.63M|{ return LABEL; } 1333| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1334| 56.3k|case 13: ------------------ | Branch (1334:1): [True: 56.3k, False: 17.2M] ------------------ 1335| 56.3k|YY_RULE_SETUP ------------------ | | 1146| 56.3k| YY_USER_ACTION | | ------------------ | | | | 890| 56.3k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 56.3k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 56.3k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 56.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1336| 56.3k|#line 112 "/src/igraph/src/io/dl-lexer.l" 1337| 56.3k|{ return DIGIT; } 1338| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1339| 2.24k|case 14: ------------------ | Branch (1339:1): [True: 2.24k, False: 17.2M] ------------------ 1340| 2.24k|YY_RULE_SETUP ------------------ | | 1146| 2.24k| YY_USER_ACTION | | ------------------ | | | | 890| 2.24k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.24k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.24k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.24k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1341| 2.24k|#line 113 "/src/igraph/src/io/dl-lexer.l" 1342| 2.24k|{ return LABEL; } 1343| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1344| 2.90M|case 15: ------------------ | Branch (1344:1): [True: 2.90M, False: 14.3M] ------------------ 1345| 2.90M|YY_RULE_SETUP ------------------ | | 1146| 2.90M| YY_USER_ACTION | | ------------------ | | | | 890| 2.90M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.90M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.90M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.90M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1346| 2.90M|#line 114 "/src/igraph/src/io/dl-lexer.l" 1347| 2.90M|{ } 1348| 2.90M| YY_BREAK ------------------ | | 1142| 2.90M|#define YY_BREAK /*LINTED*/break; ------------------ 1349| 4.68M|case 16: ------------------ | Branch (1349:1): [True: 4.68M, False: 12.5M] ------------------ 1350| 4.68M|YY_RULE_SETUP ------------------ | | 1146| 4.68M| YY_USER_ACTION | | ------------------ | | | | 890| 4.68M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 4.68M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 4.68M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 4.68M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1351| 4.68M|#line 116 "/src/igraph/src/io/dl-lexer.l" 1352| 4.68M|{ return NUM; } 1353| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1354| 1.67k|case 17: ------------------ | Branch (1354:1): [True: 1.67k, False: 17.2M] ------------------ 1355| 1.67k|YY_RULE_SETUP ------------------ | | 1146| 1.67k| YY_USER_ACTION | | ------------------ | | | | 890| 1.67k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.67k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.67k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.67k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1356| 1.67k|#line 117 "/src/igraph/src/io/dl-lexer.l" 1357| 1.67k|{ return LABEL; } 1358| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1359| 2.36M|case 18: ------------------ | Branch (1359:1): [True: 2.36M, False: 14.9M] ------------------ 1360| 2.36M|YY_RULE_SETUP ------------------ | | 1146| 2.36M| YY_USER_ACTION | | ------------------ | | | | 890| 2.36M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.36M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.36M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.36M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1361| 2.36M|#line 118 "/src/igraph/src/io/dl-lexer.l" 1362| 2.36M|{ } 1363| 2.36M| YY_BREAK ------------------ | | 1142| 2.36M|#define YY_BREAK /*LINTED*/break; ------------------ 1364| 1.52M|case 19: ------------------ | Branch (1364:1): [True: 1.52M, False: 15.7M] ------------------ 1365| 1.52M|YY_RULE_SETUP ------------------ | | 1146| 1.52M| YY_USER_ACTION | | ------------------ | | | | 890| 1.52M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.52M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.52M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.52M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1366| 1.52M|#line 120 "/src/igraph/src/io/dl-lexer.l" 1367| 1.52M|{ return NUM; } 1368| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1369| 6.84k|case 20: ------------------ | Branch (1369:1): [True: 6.84k, False: 17.2M] ------------------ 1370| 6.84k|YY_RULE_SETUP ------------------ | | 1146| 6.84k| YY_USER_ACTION | | ------------------ | | | | 890| 6.84k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 6.84k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 6.84k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 6.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1371| 6.84k|#line 121 "/src/igraph/src/io/dl-lexer.l" 1372| 6.84k|{ return LABEL; } 1373| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1374| 1.53M|case 21: ------------------ | Branch (1374:1): [True: 1.53M, False: 15.7M] ------------------ 1375| 1.53M|YY_RULE_SETUP ------------------ | | 1146| 1.53M| YY_USER_ACTION | | ------------------ | | | | 890| 1.53M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.53M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.53M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.53M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1376| 1.53M|#line 122 "/src/igraph/src/io/dl-lexer.l" 1377| 1.53M|{ } 1378| 1.53M| YY_BREAK ------------------ | | 1142| 1.53M|#define YY_BREAK /*LINTED*/break; ------------------ 1379| 64|case 22: ------------------ | Branch (1379:1): [True: 64, False: 17.2M] ------------------ 1380| 64|YY_RULE_SETUP ------------------ | | 1146| 64| YY_USER_ACTION | | ------------------ | | | | 890| 64|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 64| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 64|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 64|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1381| 64|#line 124 "/src/igraph/src/io/dl-lexer.l" 1382| 64|{ /* eaten up */ } 1383| 64| YY_BREAK ------------------ | | 1142| 64|#define YY_BREAK /*LINTED*/break; ------------------ 1384| 838|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 838|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 838|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1384:1): [True: 838, False: 17.2M] ------------------ 1385| 904|case YY_STATE_EOF(LABELM): ------------------ | | 377| 904|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 904|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1385:1): [True: 66, False: 17.2M] ------------------ 1386| 1.34k|case YY_STATE_EOF(FULLMATRIX): ------------------ | | 377| 1.34k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.34k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1386:1): [True: 438, False: 17.2M] ------------------ 1387| 1.82k|case YY_STATE_EOF(EDGELIST): ------------------ | | 377| 1.82k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.82k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1387:1): [True: 482, False: 17.2M] ------------------ 1388| 2.21k|case YY_STATE_EOF(NODELIST): ------------------ | | 377| 2.21k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.21k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1388:1): [True: 393, False: 17.2M] ------------------ 1389| 2.21k|#line 126 "/src/igraph/src/io/dl-lexer.l" 1390| 2.21k|{ 1391| 2.21k| if (yyextra->eof) { ------------------ | | 358| 2.21k|#define yyextra yyg->yyextra_r ------------------ | Branch (1391:31): [True: 805, False: 1.41k] ------------------ 1392| 805| yyterminate(); ------------------ | | 1105| 805|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 805|#define YY_NULL 0 | | ------------------ ------------------ 1393| 1.41k| } else { 1394| 1.41k| yyextra->eof=1; ------------------ | | 358| 1.41k|#define yyextra yyg->yyextra_r ------------------ 1395| 1.41k| BEGIN(INITIAL); ------------------ | | 369| 1.41k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 904| 1.41k|#define INITIAL 0 ------------------ 1396| 1.41k| return EOFF; 1397| 1.41k| } 1398| 2.21k| } 1399| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1400| 164|case 23: ------------------ | Branch (1400:1): [True: 164, False: 17.2M] ------------------ 1401| 164|YY_RULE_SETUP ------------------ | | 1146| 164| YY_USER_ACTION | | ------------------ | | | | 890| 164|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 164| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 164|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 164|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1402| 164|#line 136 "/src/igraph/src/io/dl-lexer.l" 1403| 164|{ return 0; } 1404| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1405| 0|case 24: ------------------ | Branch (1405:1): [True: 0, False: 17.2M] ------------------ 1406| 0|YY_RULE_SETUP ------------------ | | 1146| 0| YY_USER_ACTION | | ------------------ | | | | 890| 0|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 0|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1407| 0|#line 137 "/src/igraph/src/io/dl-lexer.l" 1408| 0|YY_FATAL_ERROR( "flex scanner jammed" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1409| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1410| 0|#line 1411 "/src/igraph/build/src/io/parsers/dl-lexer.c" 1411| | 1412| 11.6k| case YY_END_OF_BUFFER: ------------------ | | 594| 11.6k|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1412:2): [True: 11.6k, False: 17.2M] ------------------ 1413| 11.6k| { 1414| | /* Amount of text matched not including the EOB char. */ 1415| 11.6k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 577| 11.6k|#define yytext_ptr yytext_r ------------------ 1416| | 1417| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1418| 11.6k| *yy_cp = yyg->yy_hold_char; 1419| 11.6k| YY_RESTORE_YY_MORE_OFFSET 1420| | 1421| 11.6k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 527| 11.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 498| 11.6k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1421:8): [True: 3.12k, False: 8.57k] ------------------ 1422| 3.12k| { 1423| | /* We're scanning a new file or input source. It's 1424| | * possible that this happened because the user 1425| | * just pointed yyin at a new source and called 1426| | * yylex(). If so, then we have to assure 1427| | * consistency between YY_CURRENT_BUFFER and our 1428| | * globals. Here is the right place to do so, because 1429| | * this is the first action (other than possibly a 1430| | * back-up) that will match for the new input source. 1431| | */ 1432| 3.12k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 3.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1433| 3.12k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 527| 3.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 3.12k|#define yyin yyg->yyin_r ------------------ 1434| 3.12k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 527| 3.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 499| 3.12k|#define YY_BUFFER_NORMAL 1 ------------------ 1435| 3.12k| } 1436| | 1437| | /* Note that here we test for yy_c_buf_p "<=" to the position 1438| | * of the first EOB in the buffer, since yy_c_buf_p will 1439| | * already have been incremented past the NUL character 1440| | * (since all states make transitions on EOB to the 1441| | * end-of-buffer state). Contrast this with the test 1442| | * in input(). 1443| | */ 1444| 11.6k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 527| 11.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1444:8): [True: 210, False: 11.4k] ------------------ 1445| 210| { /* This was really a NUL. */ 1446| 210| yy_state_type yy_next_state; 1447| | 1448| 210| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 210|#define yytext_ptr yytext_r ------------------ 1449| | 1450| 210| yy_current_state = yy_get_previous_state( yyscanner ); 1451| | 1452| | /* Okay, we're now positioned to make the NUL 1453| | * transition. We couldn't have 1454| | * yy_get_previous_state() go ahead and do it 1455| | * for us because it doesn't know how to deal 1456| | * with the possibility of jamming (and we don't 1457| | * want to build jamming into it because then it 1458| | * will run more slowly). 1459| | */ 1460| | 1461| 210| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1462| | 1463| 210| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 210|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 210|#define YY_MORE_ADJ 0 ------------------ 1464| | 1465| 210| if ( yy_next_state ) ------------------ | Branch (1465:9): [True: 72, False: 138] ------------------ 1466| 72| { 1467| | /* Consume the NUL. */ 1468| 72| yy_cp = ++yyg->yy_c_buf_p; 1469| 72| yy_current_state = yy_next_state; 1470| 72| goto yy_match; 1471| 72| } 1472| | 1473| 138| else 1474| 138| { 1475| 138| yy_cp = yyg->yy_c_buf_p; 1476| 138| goto yy_find_action; 1477| 138| } 1478| 210| } 1479| | 1480| 11.4k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1480:17): [True: 11.4k, False: 0] ------------------ 1481| 11.4k| { 1482| 2.21k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 2.21k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1482:4): [True: 2.21k, False: 9.26k] ------------------ 1483| 2.21k| { 1484| 2.21k| yyg->yy_did_buffer_switch_on_eof = 0; 1485| | 1486| 2.21k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 2.21k|#define yywrap igraph_dl_yywrap | | ------------------ | | | | 571| 2.21k|#define igraph_dl_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (571:37): [True: 2.21k, Folded] | | | | ------------------ | | ------------------ ------------------ 1487| 2.21k| { 1488| | /* Note: because we've taken care in 1489| | * yy_get_next_buffer() to have set up 1490| | * yytext, we can now set up 1491| | * yy_c_buf_p so that if some total 1492| | * hoser (like flex itself) wants to 1493| | * call the scanner after we return the 1494| | * YY_NULL, it'll still work - another 1495| | * YY_NULL will get returned. 1496| | */ 1497| 2.21k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.21k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.21k|#define YY_MORE_ADJ 0 ------------------ 1498| | 1499| 2.21k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 2.21k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.21k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ 1500| 2.21k| goto do_action; 1501| 2.21k| } 1502| | 1503| 0| else 1504| 0| { 1505| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1505:11): [True: 0, False: 0] ------------------ 1506| 0| YY_NEW_FILE; ------------------ | | 379| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart igraph_dl_yyrestart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 1507| 0| } 1508| 0| break; 1509| 2.21k| } 1510| | 1511| 7.20k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 7.20k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1511:4): [True: 7.20k, False: 4.28k] ------------------ 1512| 7.20k| yyg->yy_c_buf_p = 1513| 7.20k| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 7.20k|#define yytext_ptr yytext_r ------------------ 1514| | 1515| 7.20k| yy_current_state = yy_get_previous_state( yyscanner ); 1516| | 1517| 7.20k| yy_cp = yyg->yy_c_buf_p; 1518| 7.20k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 7.20k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 7.20k|#define YY_MORE_ADJ 0 ------------------ 1519| 7.20k| goto yy_match; 1520| | 1521| 2.06k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 2.06k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1521:4): [True: 2.06k, False: 9.42k] ------------------ 1522| 2.06k| yyg->yy_c_buf_p = 1523| 2.06k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 527| 2.06k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1524| | 1525| 2.06k| yy_current_state = yy_get_previous_state( yyscanner ); 1526| | 1527| 2.06k| yy_cp = yyg->yy_c_buf_p; 1528| 2.06k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.06k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.06k|#define YY_MORE_ADJ 0 ------------------ 1529| 2.06k| goto yy_find_action; 1530| 11.4k| } 1531| 0| break; 1532| 11.6k| } 1533| | 1534| 0| default: ------------------ | Branch (1534:2): [True: 0, False: 17.2M] ------------------ 1535| 0| YY_FATAL_ERROR( ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1536| 17.2M| "fatal flex scanner internal error--no action found" ); 1537| 17.2M| } /* end of action switch */ 1538| 17.2M| } /* end of scanning one token */ 1539| 10.4M| } /* end of user's declarations */ 1540| 10.4M|} /* end of yylex */ igraph_dl_yyrestart: 1838| 2.21k|{ 1839| 2.21k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1840| | 1841| 2.21k| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 521| 2.21k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.21k, False: 0] | | ------------------ | | 522| 2.21k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.21k| : NULL) ------------------ | Branch (1841:7): [True: 0, False: 2.21k] ------------------ 1842| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack ------------------ 1843| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1844| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer igraph_dl_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 0|#define YY_BUF_SIZE 16384 ------------------ 1845| 0| } 1846| | 1847| 2.21k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 50| 2.21k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 521| 2.21k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.21k, False: 0] | | ------------------ | | 522| 2.21k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.21k| : NULL) ------------------ 1848| 2.21k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.21k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1849| 2.21k|} igraph_dl_yy_create_buffer: 1903| 2.32k|{ 1904| 2.32k| YY_BUFFER_STATE b; 1905| | 1906| 2.32k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 2.32k|#define yyalloc igraph_dl_yyalloc ------------------ 1907| 2.32k| if ( ! b ) ------------------ | Branch (1907:7): [True: 0, False: 2.32k] ------------------ 1908| 2.32k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1909| | 1910| 2.32k| b->yy_buf_size = size; 1911| | 1912| | /* yy_ch_buf has to be 2 characters longer than the size given because 1913| | * we need to put in 2 end-of-buffer characters. 1914| | */ 1915| 2.32k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); ------------------ | | 236| 2.32k|#define yyalloc igraph_dl_yyalloc ------------------ 1916| 2.32k| if ( ! b->yy_ch_buf ) ------------------ | Branch (1916:7): [True: 0, False: 2.32k] ------------------ 1917| 2.32k| YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1918| | 1919| 2.32k| b->yy_is_our_buffer = 1; 1920| | 1921| 2.32k| yy_init_buffer( b, file , yyscanner); ------------------ | | 50| 2.32k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ 1922| | 1923| 2.32k| return b; 1924| 2.32k|} igraph_dl_yy_delete_buffer: 1931| 2.32k|{ 1932| 2.32k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1933| | 1934| 2.32k| if ( ! b ) ------------------ | Branch (1934:7): [True: 0, False: 2.32k] ------------------ 1935| 0| return; 1936| | 1937| 2.32k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 521| 2.32k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.32k, False: 0] | | ------------------ | | 522| 2.32k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.32k| : NULL) ------------------ | Branch (1937:7): [True: 2.32k, False: 0] ------------------ 1938| 2.32k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 527| 2.32k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1939| | 1940| 2.32k| if ( b->yy_is_our_buffer ) ------------------ | Branch (1940:7): [True: 2.32k, False: 0] ------------------ 1941| 2.32k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 2.32k|#define yyfree igraph_dl_yyfree ------------------ 1942| | 1943| 2.32k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 2.32k|#define yyfree igraph_dl_yyfree ------------------ 1944| 2.32k|} igraph_dl_yy_flush_buffer: 1980| 4.53k|{ 1981| 4.53k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1982| 4.53k| if ( ! b ) ------------------ | Branch (1982:7): [True: 0, False: 4.53k] ------------------ 1983| 0| return; 1984| | 1985| 4.53k| b->yy_n_chars = 0; 1986| | 1987| | /* We always need two end-of-buffer characters. The first causes 1988| | * a transition to the end-of-buffer state. The second causes 1989| | * a jam in that state. 1990| | */ 1991| 4.53k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.53k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1992| 4.53k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.53k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1993| | 1994| 4.53k| b->yy_buf_pos = &b->yy_ch_buf[0]; 1995| | 1996| 4.53k| b->yy_at_bol = 1; 1997| 4.53k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 498| 4.53k|#define YY_BUFFER_NEW 0 ------------------ 1998| | 1999| 4.53k| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 521| 4.53k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.53k, False: 0] | | ------------------ | | 522| 4.53k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.53k| : NULL) ------------------ | Branch (1999:7): [True: 2.21k, False: 2.32k] ------------------ 2000| 2.21k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.21k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2001| 4.53k|} igraph_dl_yypop_buffer_state: 2041| 2.32k|{ 2042| 2.32k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2043| 2.32k| if (!YY_CURRENT_BUFFER) ------------------ | | 521| 2.32k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.32k, False: 0] | | ------------------ | | 522| 2.32k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.32k| : NULL) ------------------ | Branch (2043:6): [True: 2.32k, False: 0] ------------------ 2044| 2.32k| return; 2045| | 2046| 0| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 26| 0|#define yy_delete_buffer igraph_dl_yy_delete_buffer ------------------ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 521| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 0, False: 0] | | ------------------ | | 522| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 0| : NULL) ------------------ 2047| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2048| 0| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2048:6): [True: 0, False: 0] ------------------ 2049| 0| --yyg->yy_buffer_stack_top; 2050| | 2051| 0| if (YY_CURRENT_BUFFER) { ------------------ | | 521| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:27): [True: 0, False: 0] | | | Branch (521:29): [True: 0, False: 0] | | ------------------ | | 522| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 0| : NULL) ------------------ 2052| 0| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 0|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2053| 0| yyg->yy_did_buffer_switch_on_eof = 1; 2054| 0| } 2055| 0|} igraph_dl_yyget_leng: 2278| 7.86M|{ 2279| 7.86M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2280| 7.86M| return yyleng; ------------------ | | 359| 7.86M|#define yyleng yyg->yyleng_r ------------------ 2281| 7.86M|} igraph_dl_yyget_text: 2288| 7.92M|{ 2289| 7.92M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2290| 7.92M| return yytext; ------------------ | | 360| 7.92M|#define yytext yyg->yytext_r ------------------ 2291| 7.92M|} igraph_dl_yyset_extra: 2298| 4.64k|{ 2299| 4.64k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2300| 4.64k| yyextra = user_defined ; ------------------ | | 358| 4.64k|#define yyextra yyg->yyextra_r ------------------ 2301| 4.64k|} igraph_dl_yyset_in: 2340| 2.32k|{ 2341| 2.32k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2342| 2.32k| yyin = _in_str ; ------------------ | | 356| 2.32k|#define yyin yyg->yyin_r ------------------ 2343| 2.32k|} igraph_dl_yylex_init_extra: 2423| 2.32k|{ 2424| 2.32k| struct yyguts_t dummy_yyguts; 2425| | 2426| 2.32k| yyset_extra (yy_user_defined, &dummy_yyguts); ------------------ | | 140| 2.32k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2427| | 2428| 2.32k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2428:9): [True: 0, False: 2.32k] ------------------ 2429| 0| errno = EINVAL; 2430| 0| return 1; 2431| 0| } 2432| | 2433| 2.32k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); ------------------ | | 236| 2.32k|#define yyalloc igraph_dl_yyalloc ------------------ 2434| | 2435| 2.32k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2435:9): [True: 0, False: 2.32k] ------------------ 2436| 0| errno = ENOMEM; 2437| 0| return 1; 2438| 0| } 2439| | 2440| | /* By setting to 0xAA, we expose bugs in 2441| | yy_init_globals. Leave at 0x00 for releases. */ 2442| 2.32k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2443| | 2444| 2.32k| yyset_extra (yy_user_defined, *ptr_yy_globals); ------------------ | | 140| 2.32k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2445| | 2446| 2.32k| return yy_init_globals ( *ptr_yy_globals ); 2447| 2.32k|} igraph_dl_yylex_destroy: 2484| 2.32k|{ 2485| 2.32k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2486| | 2487| | /* Pop the buffer stack, destroying each element. */ 2488| 4.64k| while(YY_CURRENT_BUFFER){ ------------------ | | 521| 4.64k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:27): [True: 2.32k, False: 2.32k] | | | Branch (521:29): [True: 4.64k, False: 0] | | ------------------ | | 522| 4.64k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.64k| : NULL) ------------------ 2489| 2.32k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 2.32k|#define yy_delete_buffer igraph_dl_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 521| 2.32k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.32k, False: 0] | | ------------------ | | 522| 2.32k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.32k| : NULL) ------------------ 2490| 2.32k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 2.32k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2491| 2.32k| yypop_buffer_state(yyscanner); ------------------ | | 80| 2.32k|#define yypop_buffer_state igraph_dl_yypop_buffer_state ------------------ 2492| 2.32k| } 2493| | 2494| | /* Destroy the stack itself. */ 2495| 2.32k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 2.32k|#define yyfree igraph_dl_yyfree ------------------ 2496| 2.32k| yyg->yy_buffer_stack = NULL; 2497| | 2498| | /* Destroy the start condition stack. */ 2499| 2.32k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 2.32k|#define yyfree igraph_dl_yyfree ------------------ 2500| 2.32k| yyg->yy_start_stack = NULL; 2501| | 2502| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2503| | * yylex() is called, initialization will occur. */ 2504| 2.32k| yy_init_globals( yyscanner); 2505| | 2506| | /* Destroy the main struct (reentrant only). */ 2507| 2.32k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 2.32k|#define yyfree igraph_dl_yyfree ------------------ 2508| | yyscanner = NULL; 2509| 2.32k| return 0; 2510| 2.32k|} igraph_dl_yyalloc: 2540| 9.28k|{ 2541| 9.28k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2542| 9.28k| (void)yyg; 2543| 9.28k| return malloc(size); 2544| 9.28k|} igraph_dl_yyrealloc: 2547| 190|{ 2548| 190| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2549| 190| (void)yyg; 2550| | 2551| | /* The cast to (char *) in the following accommodates both 2552| | * implementations that use char* generic pointers, and those 2553| | * that use void* generic pointers. It works with the latter 2554| | * because both ANSI C and C++ allow castless assignment from 2555| | * any pointer type to void*, and deal with argument conversions 2556| | * as though doing an assignment. 2557| | */ 2558| 190| return realloc(ptr, size); 2559| 190|} igraph_dl_yyfree: 2562| 11.6k|{ 2563| 11.6k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2564| 11.6k| (void)yyg; 2565| 11.6k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2566| 11.6k|} dl-lexer.c:yy_get_next_buffer: 1550| 11.4k|{ 1551| 11.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1552| 11.4k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1553| 11.4k| char *source = yyg->yytext_ptr; ------------------ | | 577| 11.4k|#define yytext_ptr yytext_r ------------------ 1554| 11.4k| int number_to_move, i; 1555| 11.4k| int ret_val; 1556| | 1557| 11.4k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1557:7): [True: 0, False: 11.4k] ------------------ 1558| 11.4k| YY_FATAL_ERROR( ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1559| 11.4k| "fatal flex scanner internal error--end of buffer missed" ); 1560| | 1561| 11.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1561:7): [True: 0, False: 11.4k] ------------------ 1562| 0| { /* Don't try to fill the buffer, so this is an EOF. */ 1563| 0| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 577| 0|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 836| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1563:8): [True: 0, False: 0] ------------------ 1564| 0| { 1565| | /* We matched a single character, the EOB, so 1566| | * treat this as a final EOF. 1567| | */ 1568| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 410| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1569| 0| } 1570| | 1571| 0| else 1572| 0| { 1573| | /* We matched some text prior to the EOB, first 1574| | * process it. 1575| | */ 1576| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 411| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1577| 0| } 1578| 0| } 1579| | 1580| | /* Try to read more data. */ 1581| | 1582| | /* First move last chars to start of buffer. */ 1583| 11.4k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 577| 11.4k|#define yytext_ptr yytext_r ------------------ 1584| | 1585| 256M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1585:15): [True: 256M, False: 11.4k] ------------------ 1586| 256M| *(dest++) = *(source++); 1587| | 1588| 11.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 510| 11.4k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1588:7): [True: 1.26k, False: 10.2k] ------------------ 1589| | /* don't do the read, it's not guaranteed to return an EOF, 1590| | * just force an EOF 1591| | */ 1592| 1.26k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 527| 1.26k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1593| | 1594| 10.2k| else 1595| 10.2k| { 1596| 10.2k| int num_to_read = 1597| 10.2k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1598| | 1599| 10.4k| while ( num_to_read <= 0 ) ------------------ | Branch (1599:11): [True: 190, False: 10.2k] ------------------ 1600| 190| { /* Not enough room in the buffer - grow it. */ 1601| | 1602| | /* just a shorter name for the current buffer */ 1603| 190| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 527| 190|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1604| | 1605| 190| int yy_c_buf_p_offset = 1606| 190| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1607| | 1608| 190| if ( b->yy_is_our_buffer ) ------------------ | Branch (1608:9): [True: 190, False: 0] ------------------ 1609| 190| { 1610| 190| int new_size = b->yy_buf_size * 2; 1611| | 1612| 190| if ( new_size <= 0 ) ------------------ | Branch (1612:10): [True: 0, False: 190] ------------------ 1613| 0| b->yy_buf_size += b->yy_buf_size / 8; 1614| 190| else 1615| 190| b->yy_buf_size *= 2; 1616| | 1617| 190| b->yy_ch_buf = (char *) 1618| | /* Include room in for 2 EOB chars. */ 1619| 190| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 190|#define yyrealloc igraph_dl_yyrealloc ------------------ 1620| 190| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1621| 190| } 1622| 0| else 1623| | /* Can't grow it, we don't own it. */ 1624| 0| b->yy_ch_buf = NULL; 1625| | 1626| 190| if ( ! b->yy_ch_buf ) ------------------ | Branch (1626:9): [True: 0, False: 190] ------------------ 1627| 190| YY_FATAL_ERROR( ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1628| 190| "fatal error - scanner input buffer overflow" ); 1629| | 1630| 190| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1631| | 1632| 190| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 527| 190|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1633| 190| number_to_move - 1; 1634| | 1635| 190| } 1636| | 1637| 10.2k| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 1052| 10.2k|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1637:8): [True: 9.53k, False: 690] ------------------ 1638| 9.53k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1052| 9.53k|#define YY_READ_BUF_SIZE 8192 ------------------ 1639| | 1640| | /* Read in more data. */ 1641| 10.2k| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 1069| 10.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (1069:7): [True: 0, False: 10.2k] | | ------------------ | | 1070| 10.2k| { \ | | 1071| 0| int c = '*'; \ | | 1072| 0| int n; \ | | 1073| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (1073:16): [True: 0, False: 0] | | ------------------ | | 1074| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1074:9): [True: 0, False: 0] | | | Branch (1074:38): [True: 0, False: 0] | | ------------------ | | 1075| 0| buf[n] = (char) c; \ | | 1076| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (1076:8): [True: 0, False: 0] | | ------------------ | | 1077| 0| buf[n++] = (char) c; \ | | 1078| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1078:8): [True: 0, False: 0] | | | Branch (1078:20): [True: 0, False: 0] | | ------------------ | | 1079| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | | | ------------------ | | | | | | 895| 0| do { \ | | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | | | 897| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (897:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1080| 0| result = n; \ | | 1081| 0| } \ | | 1082| 10.2k| else \ | | 1083| 10.2k| { \ | | 1084| 10.2k| errno=0; \ | | 1085| 10.2k| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 10.2k|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 356| 3.01k|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1085:11): [True: 3.01k, False: 7.20k] | | | Branch (1085:78): [True: 0, False: 3.01k] | | ------------------ | | 1086| 10.2k| { \ | | 1087| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1087:8): [True: 0, False: 0] | | ------------------ | | 1088| 0| { \ | | 1089| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | | | ------------------ | | | | | | 895| 0| do { \ | | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | | | 897| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (897:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1090| 0| break; \ | | 1091| 0| } \ | | 1092| 0| errno=0; \ | | 1093| 0| clearerr(yyin); \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | 1094| 0| } \ | | 1095| 10.2k| }\ ------------------ 1642| 10.2k| yyg->yy_n_chars, num_to_read ); 1643| | 1644| 10.2k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1645| 10.2k| } 1646| | 1647| 11.4k| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1647:7): [True: 4.28k, False: 7.20k] ------------------ 1648| 4.28k| { 1649| 4.28k| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 836| 4.28k|#define YY_MORE_ADJ 0 ------------------ | Branch (1649:8): [True: 2.21k, False: 2.06k] ------------------ 1650| 2.21k| { 1651| 2.21k| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 2.21k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1652| 2.21k| yyrestart( yyin , yyscanner); ------------------ | | 98| 2.21k|#define yyrestart igraph_dl_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 2.21k|#define yyin yyg->yyin_r ------------------ 1653| 2.21k| } 1654| | 1655| 2.06k| else 1656| 2.06k| { 1657| 2.06k| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 2.06k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1658| 2.06k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 527| 2.06k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1659| 2.06k| YY_BUFFER_EOF_PENDING; ------------------ | | 510| 2.06k|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1660| 2.06k| } 1661| 4.28k| } 1662| | 1663| 7.20k| else 1664| 7.20k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 7.20k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1665| | 1666| 11.4k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1666:6): [True: 0, False: 11.4k] ------------------ 1667| | /* Extend the array by 50%, plus the number we really need. */ 1668| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1669| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 242| 0|#define yyrealloc igraph_dl_yyrealloc ------------------ 1670| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1671| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1671:8): [True: 0, False: 0] ------------------ 1672| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1673| | /* "- 2" to take care of EOB's */ 1674| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1675| 0| } 1676| | 1677| 11.4k| yyg->yy_n_chars += number_to_move; 1678| 11.4k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 11.4k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1679| 11.4k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 11.4k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1680| | 1681| 11.4k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 577| 11.4k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1682| | 1683| 11.4k| return ret_val; 1684| 11.4k|} dl-lexer.c:yy_get_previous_state: 1689| 9.47k|{ 1690| 9.47k| yy_state_type yy_current_state; 1691| 9.47k| char *yy_cp; 1692| 9.47k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1693| | 1694| 9.47k| yy_current_state = yyg->yy_start; 1695| | 1696| 258M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 577| 9.47k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 836| 9.47k|#define YY_MORE_ADJ 0 ------------------ | Branch (1696:47): [True: 258M, False: 9.47k] ------------------ 1697| 258M| { 1698| 258M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 46); ------------------ | | 346| 258M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1698:19): [True: 258M, False: 65] ------------------ 1699| 258M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1699:8): [True: 256M, False: 1.64M] ------------------ 1700| 256M| { 1701| 256M| yyg->yy_last_accepting_state = yy_current_state; 1702| 256M| yyg->yy_last_accepting_cpos = yy_cp; 1703| 256M| } 1704| 292M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1704:11): [True: 34.2M, False: 258M] ------------------ 1705| 34.2M| { 1706| 34.2M| yy_current_state = (int) yy_def[yy_current_state]; 1707| 34.2M| if ( yy_current_state >= 129 ) ------------------ | Branch (1707:9): [True: 32.7M, False: 1.52M] ------------------ 1708| 32.7M| yy_c = yy_meta[yy_c]; 1709| 34.2M| } 1710| 258M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1711| 258M| } 1712| | 1713| 9.47k| return yy_current_state; 1714| 9.47k|} dl-lexer.c:yy_try_NUL_trans: 1722| 210|{ 1723| 210| int yy_is_jam; 1724| 210| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ 1725| 210| char *yy_cp = yyg->yy_c_buf_p; 1726| | 1727| 210| YY_CHAR yy_c = 46; 1728| 210| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1728:7): [True: 121, False: 89] ------------------ 1729| 121| { 1730| 121| yyg->yy_last_accepting_state = yy_current_state; 1731| 121| yyg->yy_last_accepting_cpos = yy_cp; 1732| 121| } 1733| 428| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1733:10): [True: 218, False: 210] ------------------ 1734| 218| { 1735| 218| yy_current_state = (int) yy_def[yy_current_state]; 1736| 218| if ( yy_current_state >= 129 ) ------------------ | Branch (1736:8): [True: 66, False: 152] ------------------ 1737| 66| yy_c = yy_meta[yy_c]; 1738| 218| } 1739| 210| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1740| 210| yy_is_jam = (yy_current_state == 128); 1741| | 1742| 210| (void)yyg; 1743| 210| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (1743:9): [True: 138, False: 72] ------------------ 1744| 210|} dl-lexer.c:igraph_dl_yy_load_buffer_state: 1888| 6.75k|{ 1889| 6.75k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1890| 6.75k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 6.75k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1891| 6.75k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 577| 6.75k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 527| 6.75k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1892| 6.75k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 6.75k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 527| 6.75k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1893| 6.75k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1894| 6.75k|} dl-lexer.c:igraph_dl_yy_init_buffer: 1952| 4.53k|{ 1953| 4.53k| int oerrno = errno; 1954| 4.53k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1955| | 1956| 4.53k| yy_flush_buffer( b , yyscanner); ------------------ | | 56| 4.53k|#define yy_flush_buffer igraph_dl_yy_flush_buffer ------------------ 1957| | 1958| 4.53k| b->yy_input_file = file; 1959| 4.53k| b->yy_fill_buffer = 1; 1960| | 1961| | /* If b is the current buffer, then yy_init_buffer was _probably_ 1962| | * called from yyrestart() or through yy_get_next_buffer. 1963| | * In that case, we don't want to reset the lineno or column. 1964| | */ 1965| 4.53k| if (b != YY_CURRENT_BUFFER){ ------------------ | | 521| 4.53k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.53k, False: 0] | | ------------------ | | 522| 4.53k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.53k| : NULL) ------------------ | Branch (1965:9): [True: 2.32k, False: 2.21k] ------------------ 1966| 2.32k| b->yy_bs_lineno = 1; 1967| 2.32k| b->yy_bs_column = 0; 1968| 2.32k| } 1969| | 1970| 4.53k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (1970:32): [True: 4.53k, False: 0] ------------------ 1971| | 1972| | errno = oerrno; 1973| 4.53k|} dl-lexer.c:igraph_dl_yyensure_buffer_stack: 2061| 2.32k|{ 2062| 2.32k| yy_size_t num_to_alloc; 2063| 2.32k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2064| | 2065| 2.32k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2065:6): [True: 2.32k, False: 0] ------------------ 2066| | 2067| | /* First allocation is just for 2 elements, since we don't know if this 2068| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2069| | * immediate realloc on the next call. 2070| | */ 2071| 2.32k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2072| 2.32k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 2.32k|#define yyalloc igraph_dl_yyalloc ------------------ 2073| 2.32k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2074| 2.32k| , yyscanner); 2075| 2.32k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2075:8): [True: 0, False: 2.32k] ------------------ 2076| 2.32k| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2077| | 2078| 2.32k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2079| | 2080| 2.32k| yyg->yy_buffer_stack_max = num_to_alloc; 2081| 2.32k| yyg->yy_buffer_stack_top = 0; 2082| 2.32k| return; 2083| 2.32k| } 2084| | 2085| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2085:6): [True: 0, False: 0] ------------------ 2086| | 2087| | /* Increase the buffer to prepare for a possible push. */ 2088| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2089| | 2090| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2091| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 242| 0|#define yyrealloc igraph_dl_yyrealloc ------------------ 2092| 0| (yyg->yy_buffer_stack, 2093| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2094| 0| , yyscanner); 2095| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2095:8): [True: 0, False: 0] ------------------ 2096| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2097| | 2098| | /* zero only the new slots.*/ 2099| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2100| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2101| 0| } 2102| 0|} dl-lexer.c:yy_init_globals: 2450| 4.64k|{ 2451| 4.64k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2452| | /* Initialization is the same as for the non-reentrant scanner. 2453| | * This function is called from yylex_destroy(), so don't allocate here. 2454| | */ 2455| | 2456| 4.64k| yyg->yy_buffer_stack = NULL; 2457| 4.64k| yyg->yy_buffer_stack_top = 0; 2458| 4.64k| yyg->yy_buffer_stack_max = 0; 2459| 4.64k| yyg->yy_c_buf_p = NULL; 2460| 4.64k| yyg->yy_init = 0; 2461| 4.64k| yyg->yy_start = 0; 2462| | 2463| 4.64k| yyg->yy_start_stack_ptr = 0; 2464| 4.64k| yyg->yy_start_stack_depth = 0; 2465| 4.64k| yyg->yy_start_stack = NULL; 2466| | 2467| |/* Defined in main.c */ 2468| |#ifdef YY_STDINIT 2469| | yyin = stdin; 2470| | yyout = stdout; 2471| |#else 2472| 4.64k| yyin = NULL; ------------------ | | 356| 4.64k|#define yyin yyg->yyin_r ------------------ 2473| 4.64k| yyout = NULL; ------------------ | | 357| 4.64k|#define yyout yyg->yyout_r ------------------ 2474| 4.64k|#endif 2475| | 2476| | /* For future reference: Set errno on error, since we are called by 2477| | * yylex_init() 2478| | */ 2479| 4.64k| return 0; 2480| 4.64k|} igraph_dl_yyparse: 1291| 2.32k|{ 1292| |/* The lookahead symbol. */ 1293| 2.32k|int yychar; 1294| | 1295| | 1296| |/* The semantic value of the lookahead symbol. */ 1297| |/* Default value used for initialization, for pacifying older GCCs 1298| | or non-GCC compilers. */ 1299| 2.32k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 370| 2.32k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1300| 2.32k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 370| 2.32k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1301| | 1302| |/* Location data for the lookahead symbol. */ 1303| 2.32k|static YYLTYPE yyloc_default 1304| 2.32k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1305| 2.32k| = { 1, 1, 1, 1 } 1306| 2.32k|# endif 1307| 2.32k|; 1308| 2.32k|YYLTYPE yylloc = yyloc_default; 1309| | 1310| | /* Number of syntax errors so far. */ 1311| 2.32k| int yynerrs; 1312| | 1313| 2.32k| yy_state_fast_t yystate; 1314| | /* Number of tokens to shift before error messages enabled. */ 1315| 2.32k| int yyerrstatus; 1316| | 1317| | /* The stacks and their tools: 1318| | 'yyss': related to states. 1319| | 'yyvs': related to semantic values. 1320| | 'yyls': related to locations. 1321| | 1322| | Refer to the stacks through separate pointers, to allow yyoverflow 1323| | to reallocate them elsewhere. */ 1324| | 1325| | /* The state stack. */ 1326| 2.32k| yy_state_t yyssa[YYINITDEPTH]; 1327| 2.32k| yy_state_t *yyss; 1328| 2.32k| yy_state_t *yyssp; 1329| | 1330| | /* The semantic value stack. */ 1331| 2.32k| YYSTYPE yyvsa[YYINITDEPTH]; 1332| 2.32k| YYSTYPE *yyvs; 1333| 2.32k| YYSTYPE *yyvsp; 1334| | 1335| | /* The location stack. */ 1336| 2.32k| YYLTYPE yylsa[YYINITDEPTH]; 1337| 2.32k| YYLTYPE *yyls; 1338| 2.32k| YYLTYPE *yylsp; 1339| | 1340| | /* The locations where the error started and ended. */ 1341| 2.32k| YYLTYPE yyerror_range[3]; 1342| | 1343| 2.32k| YYPTRDIFF_T yystacksize; ------------------ | | 285| 2.32k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1344| | 1345| 2.32k| int yyn; 1346| 2.32k| int yyresult; 1347| | /* Lookahead token as an internal (translated) token number. */ 1348| 2.32k| int yytoken = 0; 1349| | /* The variables used to return semantic value and location from the 1350| | action routines. */ 1351| 2.32k| YYSTYPE yyval; 1352| 2.32k| YYLTYPE yyloc; 1353| | 1354| 2.32k|#if YYERROR_VERBOSE 1355| | /* Buffer for error messages, and its allocated size. */ 1356| 2.32k| char yymsgbuf[128]; 1357| 2.32k| char *yymsg = yymsgbuf; 1358| 2.32k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 285| 2.32k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1359| 2.32k|#endif 1360| | 1361| 2.32k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) 1362| | 1363| | /* The number of symbols on the RHS of the reduced rule. 1364| | Keep to zero when no symbol should be popped. */ 1365| 2.32k| int yylen = 0; 1366| | 1367| 2.32k| yyssp = yyss = yyssa; 1368| 2.32k| yyvsp = yyvs = yyvsa; 1369| 2.32k| yylsp = yyls = yylsa; 1370| 2.32k| yystacksize = YYINITDEPTH; ------------------ | | 1016| 2.32k|# define YYINITDEPTH 200 ------------------ 1371| | 1372| 2.32k| YYDPRINTF ((stderr, "Starting parse\n")); 1373| | 1374| 2.32k| yystate = 0; 1375| 2.32k| yyerrstatus = 0; 1376| 2.32k| yynerrs = 0; ------------------ | | 71| 2.32k|#define yynerrs igraph_dl_yynerrs ------------------ 1377| 2.32k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 780| 2.32k|#define YYEMPTY (-2) ------------------ 1378| 2.32k| yylsp[0] = yylloc; 1379| 2.32k| goto yysetstate; 1380| | 1381| | 1382| |/*------------------------------------------------------------. 1383| || yynewstate -- push a new state, which is found in yystate. | 1384| |`------------------------------------------------------------*/ 1385| 26.3M|yynewstate: 1386| | /* In all cases, when you get here, the value and location stacks 1387| | have just been pushed. So pushing a state here evens the stacks. */ 1388| 26.3M| yyssp++; 1389| | 1390| | 1391| |/*--------------------------------------------------------------------. 1392| || yysetstate -- set current state (the top of the stack) to yystate. | 1393| |`--------------------------------------------------------------------*/ 1394| 26.3M|yysetstate: 1395| 26.3M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1396| 26.3M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 393| 26.3M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (393:31): [Folded, False: 26.3M] | | | Branch (393:37): [True: 0, False: 0] | | | Branch (393:37): [True: 0, False: 0] | | ------------------ ------------------ 1397| 26.3M| YY_IGNORE_USELESS_CAST_BEGIN 1398| 26.3M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 126| 26.3M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1399| 26.3M| YY_IGNORE_USELESS_CAST_END 1400| | 1401| 26.3M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1401:7): [True: 0, False: 26.3M] ------------------ 1402| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1403| | goto yyexhaustedlab; 1404| |#else 1405| 0| { 1406| | /* Get the current used size of the three stacks, in elements. */ 1407| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 285| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1408| | 1409| |# if defined yyoverflow 1410| | { 1411| | /* Give user a chance to reallocate the stack. Use copies of 1412| | these so that the &'s don't force the real ones into 1413| | memory. */ 1414| | yy_state_t *yyss1 = yyss; 1415| | YYSTYPE *yyvs1 = yyvs; 1416| | YYLTYPE *yyls1 = yyls; 1417| | 1418| | /* Each stack pointer address is followed by the size of the 1419| | data in use in that stack, in bytes. This used to be a 1420| | conditional around just the two extra args, but that might 1421| | be undefined if yyoverflow is a macro. */ 1422| | yyoverflow (YY_("memory exhausted"), 1423| | &yyss1, yysize * YYSIZEOF (*yyssp), 1424| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1425| | &yyls1, yysize * YYSIZEOF (*yylsp), 1426| | &yystacksize); 1427| | yyss = yyss1; 1428| | yyvs = yyvs1; 1429| | yyls = yyls1; 1430| | } 1431| |# else /* defined YYSTACK_RELOCATE */ 1432| | /* Extend the stack our own way. */ 1433| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1027| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1433:11): [True: 0, False: 0] ------------------ 1434| 0| goto yyexhaustedlab; 1435| 0| yystacksize *= 2; 1436| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1027| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (1436:11): [True: 0, False: 0] ------------------ 1437| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1027| 0|# define YYMAXDEPTH 10000 ------------------ 1438| | 1439| 0| { 1440| 0| yy_state_t *yyss1 = yyss; 1441| 0| union yyalloc *yyptr = 1442| 0| YY_CAST (union yyalloc *, ------------------ | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1443| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1444| 0| if (! yyptr) ------------------ | Branch (1444:13): [True: 0, False: 0] ------------------ 1445| 0| goto yyexhaustedlab; 1446| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 494| 0| do \ | | 495| 0| { \ | | 496| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 285| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 497| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 512| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 498| 0| Stack = &yyptr->Stack_alloc; \ | | 499| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 477| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 500| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 501| 0| } \ | | 502| 0| while (0) | | ------------------ | | | Branch (502:12): [Folded, False: 0] | | ------------------ ------------------ 1447| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 494| 0| do \ | | 495| 0| { \ | | 496| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 285| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 497| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 512| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 498| 0| Stack = &yyptr->Stack_alloc; \ | | 499| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 477| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 500| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 501| 0| } \ | | 502| 0| while (0) | | ------------------ | | | Branch (502:12): [Folded, False: 0] | | ------------------ ------------------ 1448| 0| YYSTACK_RELOCATE (yyls_alloc, yyls); ------------------ | | 494| 0| do \ | | 495| 0| { \ | | 496| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 285| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 497| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 512| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 498| 0| Stack = &yyptr->Stack_alloc; \ | | 499| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 477| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 500| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 318| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 501| 0| } \ | | 502| 0| while (0) | | ------------------ | | | Branch (502:12): [Folded, False: 0] | | ------------------ ------------------ 1449| 0|# undef YYSTACK_RELOCATE 1450| 0| if (yyss1 != yyssa) ------------------ | Branch (1450:13): [True: 0, False: 0] ------------------ 1451| 0| YYSTACK_FREE (yyss1); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 1452| 0| } 1453| 0|# endif 1454| | 1455| 0| yyssp = yyss + yysize - 1; 1456| 0| yyvsp = yyvs + yysize - 1; 1457| 0| yylsp = yyls + yysize - 1; 1458| | 1459| 0| YY_IGNORE_USELESS_CAST_BEGIN 1460| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n", 1461| 0| YY_CAST (long, yystacksize))); 1462| 0| YY_IGNORE_USELESS_CAST_END 1463| | 1464| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1464:11): [True: 0, False: 0] ------------------ 1465| 0| YYABORT; ------------------ | | 784| 0|#define YYABORT goto yyabortlab ------------------ 1466| 0| } 1467| 26.3M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1468| | 1469| 26.3M| if (yystate == YYFINAL) ------------------ | | 527| 26.3M|#define YYFINAL 4 ------------------ | Branch (1469:7): [True: 827, False: 26.3M] ------------------ 1470| 827| YYACCEPT; ------------------ | | 783| 827|#define YYACCEPT goto yyacceptlab ------------------ 1471| | 1472| 26.3M| goto yybackup; 1473| | 1474| | 1475| |/*-----------. 1476| || yybackup. | 1477| |`-----------*/ 1478| 26.3M|yybackup: 1479| | /* Do appropriate processing given the current state. Read a 1480| | lookahead token if we need one and don't already have one. */ 1481| | 1482| | /* First try to decide what to do without reference to lookahead token. */ 1483| 26.3M| yyn = yypact[yystate]; 1484| 26.3M| if (yypact_value_is_default (yyn)) ------------------ | | 632| 26.3M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 26.3M|#define YYPACT_NINF (-114) | | ------------------ | | | Branch (632:3): [True: 14.3M, False: 11.9M] | | ------------------ ------------------ 1485| 14.3M| goto yydefault; 1486| | 1487| | /* Not known => get a lookahead token if don't already have one. */ 1488| | 1489| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1490| 11.9M| if (yychar == YYEMPTY) ------------------ | | 780| 11.9M|#define YYEMPTY (-2) ------------------ | Branch (1490:7): [True: 10.4M, False: 1.47M] ------------------ 1491| 10.4M| { 1492| 10.4M| YYDPRINTF ((stderr, "Reading a token: ")); 1493| 10.4M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 68| 10.4M|#define yylex igraph_dl_yylex ------------------ yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 116| 10.4M|#define scanner context->scanner ------------------ 1494| 10.4M| } 1495| | 1496| 11.9M| if (yychar <= YYEOF) ------------------ | | 781| 11.9M|#define YYEOF 0 ------------------ | Branch (1496:7): [True: 1.04k, False: 11.9M] ------------------ 1497| 1.04k| { 1498| 1.04k| yychar = yytoken = YYEOF; ------------------ | | 781| 1.04k|#define YYEOF 0 ------------------ 1499| 1.04k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1500| 1.04k| } 1501| 11.9M| else 1502| 11.9M| { 1503| 11.9M| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 11.9M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 11.9M|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 11.9M, False: 0] | | | Branch (547:18): [True: 11.9M, False: 0] | | ------------------ ------------------ 1504| 11.9M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1505| 11.9M| } 1506| | 1507| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1508| | detect an error, take that action. */ 1509| 11.9M| yyn += yytoken; 1510| 11.9M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 529| 11.9M|#define YYLAST 118 ------------------ | Branch (1510:7): [True: 0, False: 11.9M] | Branch (1510:18): [True: 0, False: 11.9M] | Branch (1510:34): [True: 1.46M, False: 10.4M] ------------------ 1511| 1.46M| goto yydefault; 1512| 10.4M| yyn = yytable[yyn]; 1513| 10.4M| if (yyn <= 0) ------------------ | Branch (1513:7): [True: 11.9k, False: 10.4M] ------------------ 1514| 11.9k| { 1515| 11.9k| if (yytable_value_is_error (yyn)) ------------------ | | 637| 11.9k| 0 | | ------------------ | | | Branch (637:3): [Folded, False: 11.9k] | | ------------------ ------------------ 1516| 0| goto yyerrlab; 1517| 11.9k| yyn = -yyn; 1518| 11.9k| goto yyreduce; 1519| 11.9k| } 1520| | 1521| | /* Count tokens shifted since error; after three, turn off error 1522| | status. */ 1523| 10.4M| if (yyerrstatus) ------------------ | Branch (1523:7): [True: 0, False: 10.4M] ------------------ 1524| 0| yyerrstatus--; 1525| | 1526| | /* Shift the lookahead token. */ 1527| 10.4M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1528| 10.4M| yystate = yyn; 1529| 10.4M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1530| 10.4M| *++yyvsp = yylval; 1531| 10.4M| YY_IGNORE_MAYBE_UNINITIALIZED_END 1532| 10.4M| *++yylsp = yylloc; 1533| | 1534| | /* Discard the shifted token. */ 1535| 10.4M| yychar = YYEMPTY; ------------------ | | 780| 10.4M|#define YYEMPTY (-2) ------------------ 1536| 10.4M| goto yynewstate; 1537| | 1538| | 1539| |/*-----------------------------------------------------------. 1540| || yydefault -- do the default action for the current state. | 1541| |`-----------------------------------------------------------*/ 1542| 15.8M|yydefault: 1543| 15.8M| yyn = yydefact[yystate]; 1544| 15.8M| if (yyn == 0) ------------------ | Branch (1544:7): [True: 816, False: 15.8M] ------------------ 1545| 816| goto yyerrlab; 1546| 15.8M| goto yyreduce; 1547| | 1548| | 1549| |/*-----------------------------. 1550| || yyreduce -- do a reduction. | 1551| |`-----------------------------*/ 1552| 15.8M|yyreduce: 1553| | /* yyn is the number of a rule to reduce with. */ 1554| 15.8M| yylen = yyr2[yyn]; 1555| | 1556| | /* If YYLEN is nonzero, implement the default value of the action: 1557| | '$$ = $1'. 1558| | 1559| | Otherwise, the following line sets YYVAL to garbage. 1560| | This behavior is undocumented and Bison 1561| | users should not rely upon it. Assigning to YYVAL 1562| | unconditionally makes the parser a bit smaller, and it avoids a 1563| | GCC warning that YYVAL may be used uninitialized. */ 1564| 15.8M| yyval = yyvsp[1-yylen]; 1565| | 1566| | /* Default location. */ 1567| 15.8M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 818| 15.8M| do \ | | 819| 15.8M| if (N) \ | | ------------------ | | | Branch (819:11): [True: 14.3M, False: 1.48M] | | ------------------ | | 820| 15.8M| { \ | | 821| 14.3M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 836| 14.3M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 822| 14.3M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 836| 14.3M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 823| 14.3M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 836| 14.3M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 824| 14.3M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 836| 14.3M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 825| 14.3M| } \ | | 826| 15.8M| else \ | | 827| 15.8M| { \ | | 828| 1.48M| (Current).first_line = (Current).last_line = \ | | 829| 1.48M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 836| 1.48M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 830| 1.48M| (Current).first_column = (Current).last_column = \ | | 831| 1.48M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 836| 1.48M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 832| 1.48M| } \ | | 833| 15.8M| while (0) | | ------------------ | | | Branch (833:12): [Folded, False: 15.8M] | | ------------------ ------------------ 1568| 15.8M| yyerror_range[1] = yyloc; 1569| 15.8M| YY_REDUCE_PRINT (yyn); 1570| 15.8M| switch (yyn) 1571| 15.8M| { 1572| 918| case 2: ------------------ | Branch (1572:3): [True: 918, False: 15.8M] ------------------ 1573| 918|#line 104 "/src/igraph/src/io/dl-parser.y" 1574| 918| { 1575| 918| context->n=(yyvsp[-4].integer); 1576| 918| if (context->n < 0) { ------------------ | Branch (1576:7): [True: 0, False: 918] ------------------ 1577| 0| IGRAPH_YY_ERRORF("Invalid vertex count in DL file (%" IGRAPH_PRId ").", IGRAPH_EINVAL, context->n); ------------------ | | 24| 0| do { \ | | 25| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 0| error_code, __VA_ARGS__) ; \ | | 27| 0| context->igraph_errno = error_code; \ | | 28| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 29| 0| } while (0) | | ------------------ | | | Branch (29:14): [Folded, False: 0] | | ------------------ ------------------ 1578| 0| } 1579| 918| if (context->n > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 918|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (1579:7): [True: 48, False: 870] ------------------ 1580| 48| IGRAPH_YY_ERRORF("Vertex count too large in DL file (%" IGRAPH_PRId ").", IGRAPH_EINVAL, context->n); ------------------ | | 24| 48| do { \ | | 25| 48| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 48| error_code, __VA_ARGS__) ; \ | | 27| 48| context->igraph_errno = error_code; \ | | 28| 48| YYABORT; \ | | ------------------ | | | | 784| 48|#define YYABORT goto yyabortlab | | ------------------ | | 29| 48| } while (0) | | ------------------ | | | Branch (29:14): [Folded, False: 0] | | ------------------ ------------------ 1581| 48| } 1582| 918|} 1583| 870|#line 1584 "/src/igraph/build/src/io/parsers/dl-parser.c" 1584| 870| break; 1585| | 1586| 870| case 7: ------------------ | Branch (1586:3): [True: 451, False: 15.8M] ------------------ 1587| 451|#line 118 "/src/igraph/src/io/dl-parser.y" 1588| 451| { context->type=IGRAPH_DL_MATRIX; } 1589| 451|#line 1590 "/src/igraph/build/src/io/parsers/dl-parser.c" 1590| 451| break; 1591| | 1592| 359| case 8: ------------------ | Branch (1592:3): [True: 359, False: 15.8M] ------------------ 1593| 359|#line 119 "/src/igraph/src/io/dl-parser.y" 1594| 359| { context->type=IGRAPH_DL_EDGELIST1; } 1595| 359|#line 1596 "/src/igraph/build/src/io/parsers/dl-parser.c" 1596| 359| break; 1597| | 1598| 108| case 9: ------------------ | Branch (1598:3): [True: 108, False: 15.8M] ------------------ 1599| 108|#line 120 "/src/igraph/src/io/dl-parser.y" 1600| 108| { context->type=IGRAPH_DL_NODELIST1; } 1601| 108|#line 1602 "/src/igraph/build/src/io/parsers/dl-parser.c" 1602| 108| break; 1603| | 1604| 0| case 10: ------------------ | Branch (1604:3): [True: 0, False: 15.8M] ------------------ 1605| 0|#line 123 "/src/igraph/src/io/dl-parser.y" 1606| 0| {} 1607| 0|#line 1608 "/src/igraph/build/src/io/parsers/dl-parser.c" 1608| 0| break; 1609| | 1610| 451| case 11: ------------------ | Branch (1610:3): [True: 451, False: 15.8M] ------------------ 1611| 451|#line 123 "/src/igraph/src/io/dl-parser.y" 1612| 451| {} 1613| 451|#line 1614 "/src/igraph/build/src/io/parsers/dl-parser.c" 1614| 451| break; 1615| | 1616| 358| case 14: ------------------ | Branch (1616:3): [True: 358, False: 15.8M] ------------------ 1617| 358|#line 127 "/src/igraph/src/io/dl-parser.y" 1618| 358| { } 1619| 358|#line 1620 "/src/igraph/build/src/io/parsers/dl-parser.c" 1620| 358| break; 1621| | 1622| 78| case 15: ------------------ | Branch (1622:3): [True: 78, False: 15.8M] ------------------ 1623| 78|#line 128 "/src/igraph/src/io/dl-parser.y" 1624| 78| { } 1625| 78|#line 1626 "/src/igraph/build/src/io/parsers/dl-parser.c" 1626| 78| break; 1627| | 1628| 15| case 16: ------------------ | Branch (1628:3): [True: 15, False: 15.8M] ------------------ 1629| 15|#line 129 "/src/igraph/src/io/dl-parser.y" 1630| 15| { } 1631| 15|#line 1632 "/src/igraph/build/src/io/parsers/dl-parser.c" 1632| 15| break; 1633| | 1634| 335| case 17: ------------------ | Branch (1634:3): [True: 335, False: 15.8M] ------------------ 1635| 335|#line 132 "/src/igraph/src/io/dl-parser.y" 1636| 335| {} 1637| 335|#line 1638 "/src/igraph/build/src/io/parsers/dl-parser.c" 1638| 335| break; 1639| | 1640| 1.63M| case 18: ------------------ | Branch (1640:3): [True: 1.63M, False: 14.2M] ------------------ 1641| 1.63M|#line 133 "/src/igraph/src/io/dl-parser.y" 1642| 1.63M| { 1643| 1.63M| IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.63M| do { \ | | 11| 1.63M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.63M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.63M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.63M] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 1.63M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.63M] | | ------------------ ------------------ 1644| 1.63M| igraph_dl_yyget_leng(scanner), 1645| 1.63M| context)); } 1646| 1.63M|#line 1647 "/src/igraph/build/src/io/parsers/dl-parser.c" 1647| 1.63M| break; 1648| | 1649| 1.63M| case 19: ------------------ | Branch (1649:3): [True: 464, False: 15.8M] ------------------ 1650| 464|#line 139 "/src/igraph/src/io/dl-parser.y" 1651| 464| {} 1652| 464|#line 1653 "/src/igraph/build/src/io/parsers/dl-parser.c" 1653| 464| break; 1654| | 1655| 11.9k| case 20: ------------------ | Branch (1655:3): [True: 11.9k, False: 15.8M] ------------------ 1656| 11.9k|#line 139 "/src/igraph/src/io/dl-parser.y" 1657| 11.9k| { 1658| 11.9k| context->from += 1; 1659| 11.9k| context->to = 0; 1660| 11.9k| } 1661| 11.9k|#line 1662 "/src/igraph/build/src/io/parsers/dl-parser.c" 1662| 11.9k| break; 1663| | 1664| 56.3k| case 22: ------------------ | Branch (1664:3): [True: 56.3k, False: 15.7M] ------------------ 1665| 56.3k|#line 144 "/src/igraph/src/io/dl-parser.y" 1666| 56.3k| { } 1667| 56.3k|#line 1668 "/src/igraph/build/src/io/parsers/dl-parser.c" 1668| 56.3k| break; 1669| | 1670| 56.3k| case 23: ------------------ | Branch (1670:3): [True: 56.3k, False: 15.7M] ------------------ 1671| 56.3k|#line 146 "/src/igraph/src/io/dl-parser.y" 1672| 56.3k| { 1673| | /* TODO: What if the digit is neither 0 or 1? Are multigraphs allowed? */ 1674| 56.3k| char c = igraph_dl_yyget_text(scanner)[0]; ------------------ | | 116| 56.3k|#define scanner context->scanner ------------------ 1675| 56.3k| if (c == '1') { ------------------ | Branch (1675:7): [True: 55.7k, False: 627] ------------------ 1676| 55.7k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 55.7k| do { \ | | 11| 55.7k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 55.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 55.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 55.7k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 55.7k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 55.7k] | | ------------------ ------------------ 1677| 55.7k| context->from)); 1678| 55.7k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 55.7k| do { \ | | 11| 55.7k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 55.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 55.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 55.7k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 55.7k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 55.7k] | | ------------------ ------------------ 1679| 55.7k| context->to)); 1680| 55.7k| } else if (c != '0') { ------------------ | Branch (1680:14): [True: 5, False: 622] ------------------ 1681| 5| IGRAPH_YY_ERRORF("Unexpected digit '%c' in adjacency matrix in DL file.", ------------------ | | 24| 5| do { \ | | 25| 5| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 5| error_code, __VA_ARGS__) ; \ | | 27| 5| context->igraph_errno = error_code; \ | | 28| 5| YYABORT; \ | | ------------------ | | | | 784| 5|#define YYABORT goto yyabortlab | | ------------------ | | 29| 5| } while (0) | | ------------------ | | | Branch (29:14): [Folded, False: 0] | | ------------------ ------------------ 1682| 5| IGRAPH_EINVAL, c); 1683| 5| } 1684| 56.3k| context->to += 1; 1685| 56.3k|} 1686| 0|#line 1687 "/src/igraph/build/src/io/parsers/dl-parser.c" 1687| 0| break; 1688| | 1689| 15| case 24: ------------------ | Branch (1689:3): [True: 15, False: 15.8M] ------------------ 1690| 15|#line 161 "/src/igraph/src/io/dl-parser.y" 1691| 15| {} 1692| 15|#line 1693 "/src/igraph/build/src/io/parsers/dl-parser.c" 1693| 15| break; 1694| | 1695| 15| case 25: ------------------ | Branch (1695:3): [True: 15, False: 15.8M] ------------------ 1696| 15|#line 163 "/src/igraph/src/io/dl-parser.y" 1697| 15| {} 1698| 15|#line 1699 "/src/igraph/build/src/io/parsers/dl-parser.c" 1699| 15| break; 1700| | 1701| 1.99k| case 28: ------------------ | Branch (1701:3): [True: 1.99k, False: 15.8M] ------------------ 1702| 1.99k|#line 167 "/src/igraph/src/io/dl-parser.y" 1703| 1.99k| { IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.99k| do { \ | | 11| 1.99k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.99k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.99k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.99k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 1.99k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.99k] | | ------------------ ------------------ 1704| 1.99k| igraph_dl_yyget_leng(scanner), 1705| 1.99k| context)); } 1706| 1.99k|#line 1707 "/src/igraph/build/src/io/parsers/dl-parser.c" 1707| 1.99k| break; 1708| | 1709| 1.99k| case 29: ------------------ | Branch (1709:3): [True: 17, False: 15.8M] ------------------ 1710| 17|#line 171 "/src/igraph/src/io/dl-parser.y" 1711| 17| { 1712| 17| context->from += 1; 1713| 17| context->to = 0; 1714| 17| } 1715| 17|#line 1716 "/src/igraph/build/src/io/parsers/dl-parser.c" 1716| 17| break; 1717| | 1718| 195| case 30: ------------------ | Branch (1718:3): [True: 195, False: 15.8M] ------------------ 1719| 195|#line 175 "/src/igraph/src/io/dl-parser.y" 1720| 195| { 1721| 195| context->from += 1; 1722| 195| context->to = 0; 1723| 195| } 1724| 195|#line 1725 "/src/igraph/build/src/io/parsers/dl-parser.c" 1725| 195| break; 1726| | 1727| 212| case 31: ------------------ | Branch (1727:3): [True: 212, False: 15.8M] ------------------ 1728| 212|#line 180 "/src/igraph/src/io/dl-parser.y" 1729| 212| { } 1730| 212|#line 1731 "/src/igraph/build/src/io/parsers/dl-parser.c" 1731| 212| break; 1732| | 1733| 359| case 32: ------------------ | Branch (1733:3): [True: 359, False: 15.8M] ------------------ 1734| 359|#line 184 "/src/igraph/src/io/dl-parser.y" 1735| 359| {} 1736| 359|#line 1737 "/src/igraph/build/src/io/parsers/dl-parser.c" 1737| 359| break; 1738| | 1739| 329| case 33: ------------------ | Branch (1739:3): [True: 329, False: 15.8M] ------------------ 1740| 329|#line 186 "/src/igraph/src/io/dl-parser.y" 1741| 329| {} 1742| 329|#line 1743 "/src/igraph/build/src/io/parsers/dl-parser.c" 1743| 329| break; 1744| | 1745| 3| case 34: ------------------ | Branch (1745:3): [True: 3, False: 15.8M] ------------------ 1746| 3|#line 187 "/src/igraph/src/io/dl-parser.y" 1747| 3| {} 1748| 3|#line 1749 "/src/igraph/build/src/io/parsers/dl-parser.c" 1749| 3| break; 1750| | 1751| 21| case 35: ------------------ | Branch (1751:3): [True: 21, False: 15.8M] ------------------ 1752| 21|#line 188 "/src/igraph/src/io/dl-parser.y" 1753| 21| {} 1754| 21|#line 1755 "/src/igraph/build/src/io/parsers/dl-parser.c" 1755| 21| break; 1756| | 1757| 6| case 36: ------------------ | Branch (1757:3): [True: 6, False: 15.8M] ------------------ 1758| 6|#line 189 "/src/igraph/src/io/dl-parser.y" 1759| 6| {} 1760| 6|#line 1761 "/src/igraph/build/src/io/parsers/dl-parser.c" 1761| 6| break; 1762| | 1763| 0| case 37: ------------------ | Branch (1763:3): [True: 0, False: 15.8M] ------------------ 1764| 0|#line 190 "/src/igraph/src/io/dl-parser.y" 1765| 0| {} 1766| 0|#line 1767 "/src/igraph/build/src/io/parsers/dl-parser.c" 1767| 0| break; 1768| | 1769| 870| case 38: ------------------ | Branch (1769:3): [True: 870, False: 15.8M] ------------------ 1770| 870|#line 193 "/src/igraph/src/io/dl-parser.y" 1771| 870| {} 1772| 870|#line 1773 "/src/igraph/build/src/io/parsers/dl-parser.c" 1773| 870| break; 1774| | 1775| 2.32M| case 39: ------------------ | Branch (1775:3): [True: 2.32M, False: 13.5M] ------------------ 1776| 2.32M|#line 194 "/src/igraph/src/io/dl-parser.y" 1777| 2.32M| {} 1778| 2.32M|#line 1779 "/src/igraph/build/src/io/parsers/dl-parser.c" 1779| 2.32M| break; 1780| | 1781| 34.2k| case 40: ------------------ | Branch (1781:3): [True: 34.2k, False: 15.8M] ------------------ 1782| 34.2k|#line 197 "/src/igraph/src/io/dl-parser.y" 1783| 34.2k| { 1784| 34.2k| igraph_int_t from = (yyvsp[-3].integer), to = (yyvsp[-2].integer); 1785| 34.2k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 34.2k| do { \ | | 11| 34.2k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 34.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 34.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 120, False: 34.1k] | | | | ------------------ | | ------------------ | | 13| 120| context->igraph_errno = igraph_i_ret; \ | | 14| 120| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 120|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 120| YYABORT; \ | | ------------------ | | | | 784| 120|#define YYABORT goto yyabortlab | | ------------------ | | 16| 120| } \ | | 17| 34.2k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 34.1k] | | ------------------ ------------------ 1786| 34.1k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 34.1k| do { \ | | 11| 34.1k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 34.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 34.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 129, False: 33.9k] | | | | ------------------ | | ------------------ | | 13| 129| context->igraph_errno = igraph_i_ret; \ | | 14| 129| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 129|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 129| YYABORT; \ | | ------------------ | | | | 784| 129|#define YYABORT goto yyabortlab | | ------------------ | | 16| 129| } \ | | 17| 34.1k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 33.9k] | | ------------------ ------------------ 1787| 33.9k| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w(from-1, to-1, (yyvsp[-1].real), context)); } ------------------ | | 10| 33.9k| do { \ | | 11| 33.9k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 33.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 33.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 33.9k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 33.9k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 33.9k] | | ------------------ ------------------ 1788| 33.9k|#line 1789 "/src/igraph/build/src/io/parsers/dl-parser.c" 1789| 33.9k| break; 1790| | 1791| 2.29M| case 41: ------------------ | Branch (1791:3): [True: 2.29M, False: 13.5M] ------------------ 1792| 2.29M|#line 202 "/src/igraph/src/io/dl-parser.y" 1793| 2.29M| { 1794| 2.29M| igraph_int_t from = (yyvsp[-2].integer), to = (yyvsp[-1].integer); 1795| 2.29M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 2.29M| do { \ | | 11| 2.29M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.29M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 2.29M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 122, False: 2.29M] | | | | ------------------ | | ------------------ | | 13| 122| context->igraph_errno = igraph_i_ret; \ | | 14| 122| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 122|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 122| YYABORT; \ | | ------------------ | | | | 784| 122|#define YYABORT goto yyabortlab | | ------------------ | | 16| 122| } \ | | 17| 2.29M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 2.29M] | | ------------------ ------------------ 1796| 2.29M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 2.29M| do { \ | | 11| 2.29M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.29M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 2.29M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 79, False: 2.29M] | | | | ------------------ | | ------------------ | | 13| 79| context->igraph_errno = igraph_i_ret; \ | | 14| 79| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 79|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 79| YYABORT; \ | | ------------------ | | | | 784| 79|#define YYABORT goto yyabortlab | | ------------------ | | 16| 79| } \ | | 17| 2.29M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 2.29M] | | ------------------ ------------------ 1797| 2.29M| IGRAPH_YY_CHECK(igraph_i_dl_add_edge(from-1, to-1, context)); ------------------ | | 10| 2.29M| do { \ | | 11| 2.29M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.29M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 2.29M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.29M] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 2.29M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 2.29M] | | ------------------ ------------------ 1798| 2.29M|} 1799| 2.29M|#line 1800 "/src/igraph/build/src/io/parsers/dl-parser.c" 1800| 2.29M| break; 1801| | 1802| 6.18M| case 42: ------------------ | Branch (1802:3): [True: 6.18M, False: 9.67M] ------------------ 1803| 6.18M|#line 209 "/src/igraph/src/io/dl-parser.y" 1804| 6.18M| { 1805| 6.18M| igraph_int_t val; 1806| 6.18M| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 6.18M| do { \ | | 11| 6.18M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 6.18M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 6.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 33, False: 6.18M] | | | | ------------------ | | ------------------ | | 13| 33| context->igraph_errno = igraph_i_ret; \ | | 14| 33| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 33|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 33| YYABORT; \ | | ------------------ | | | | 784| 33|#define YYABORT goto yyabortlab | | ------------------ | | 16| 33| } \ | | 17| 6.18M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 6.18M] | | ------------------ ------------------ 1807| 6.18M| igraph_dl_yyget_leng(scanner), 1808| 6.18M| &val)); 1809| 6.18M| (yyval.integer)=val; 1810| 6.18M|} 1811| 0|#line 1812 "/src/igraph/build/src/io/parsers/dl-parser.c" 1812| 0| break; 1813| | 1814| 113| case 43: ------------------ | Branch (1814:3): [True: 113, False: 15.8M] ------------------ 1815| 113|#line 217 "/src/igraph/src/io/dl-parser.y" 1816| 113| {} 1817| 113|#line 1818 "/src/igraph/build/src/io/parsers/dl-parser.c" 1818| 113| break; 1819| | 1820| 782| case 44: ------------------ | Branch (1820:3): [True: 782, False: 15.8M] ------------------ 1821| 782|#line 218 "/src/igraph/src/io/dl-parser.y" 1822| 782| {} 1823| 782|#line 1824 "/src/igraph/build/src/io/parsers/dl-parser.c" 1824| 782| break; 1825| | 1826| 331| case 45: ------------------ | Branch (1826:3): [True: 331, False: 15.8M] ------------------ 1827| 331|#line 221 "/src/igraph/src/io/dl-parser.y" 1828| 331| { 1829| 331| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w((yyvsp[-3].integer), (yyvsp[-2].integer), (yyvsp[-1].real), context)); } ------------------ | | 10| 331| do { \ | | 11| 331| igraph_error_t igraph_i_ret = (expr); \ | | 12| 331| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 331| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 331] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 331| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 331] | | ------------------ ------------------ 1830| 331|#line 1831 "/src/igraph/build/src/io/parsers/dl-parser.c" 1831| 331| break; 1832| | 1833| 451| case 46: ------------------ | Branch (1833:3): [True: 451, False: 15.8M] ------------------ 1834| 451|#line 223 "/src/igraph/src/io/dl-parser.y" 1835| 451| { 1836| 451| IGRAPH_YY_CHECK(igraph_i_dl_add_edge((yyvsp[-2].integer), (yyvsp[-1].integer), context)); ------------------ | | 10| 451| do { \ | | 11| 451| igraph_error_t igraph_i_ret = (expr); \ | | 12| 451| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 451| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 451] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 451| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 451] | | ------------------ ------------------ 1837| 451| } 1838| 451|#line 1839 "/src/igraph/build/src/io/parsers/dl-parser.c" 1839| 451| break; 1840| | 1841| 34.6k| case 47: ------------------ | Branch (1841:3): [True: 34.6k, False: 15.8M] ------------------ 1842| 34.6k|#line 227 "/src/igraph/src/io/dl-parser.y" 1843| 34.6k| { 1844| 34.6k| igraph_real_t val; 1845| 34.6k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_dl_yyget_text(scanner), ------------------ | | 10| 34.6k| do { \ | | 11| 34.6k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 34.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 34.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 26, False: 34.6k] | | | | ------------------ | | ------------------ | | 13| 26| context->igraph_errno = igraph_i_ret; \ | | 14| 26| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 26|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 26| YYABORT; \ | | ------------------ | | | | 784| 26|#define YYABORT goto yyabortlab | | ------------------ | | 16| 26| } \ | | 17| 34.6k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 34.6k] | | ------------------ ------------------ 1846| 34.6k| igraph_dl_yyget_leng(scanner), 1847| 34.6k| &val)); 1848| 34.6k| (yyval.real)=val; 1849| 34.6k|} 1850| 0|#line 1851 "/src/igraph/build/src/io/parsers/dl-parser.c" 1851| 0| break; 1852| | 1853| 8.51k| case 48: ------------------ | Branch (1853:3): [True: 8.51k, False: 15.8M] ------------------ 1854| 8.51k|#line 235 "/src/igraph/src/io/dl-parser.y" 1855| 8.51k| { 1856| 8.51k| igraph_int_t trie_id; 1857| | 1858| | /* Copy label list to trie, if needed */ 1859| 8.51k| if (igraph_strvector_size(&context->labels) != 0) { ------------------ | Branch (1859:7): [True: 153, False: 8.36k] ------------------ 1860| 153| igraph_int_t i, id, n=igraph_strvector_size(&context->labels); 1861| 541k| for (i=0; itrie, igraph_strvector_get(&context->labels, i), &id)); ------------------ | | 10| 541k| do { \ | | 11| 541k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 541k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 541k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 541k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 541k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 541k] | | ------------------ ------------------ 1863| 541k| } 1864| 153| igraph_strvector_clear(&context->labels); 1865| 153| } 1866| 8.51k| IGRAPH_YY_CHECK(igraph_trie_get_len(&context->trie, igraph_dl_yyget_text(scanner), ------------------ | | 10| 8.51k| do { \ | | 11| 8.51k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 8.51k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 8.51k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.51k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 8.51k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 8.51k] | | ------------------ ------------------ 1867| 8.51k| igraph_dl_yyget_leng(scanner), &trie_id)); 1868| 8.51k| IGRAPH_ASSERT(0 <= trie_id && trie_id < IGRAPH_DL_MAX_VERTEX_COUNT); ------------------ | | 924| 8.51k| do { \ | | 925| 8.51k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.51k] | | | | | Branch (612:52): [True: 8.51k, False: 0] | | | | | Branch (612:52): [True: 8.51k, False: 0] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.51k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.51k] | | ------------------ ------------------ 1869| 8.51k| (yyval.integer) = trie_id; 1870| 8.51k| } 1871| 0|#line 1872 "/src/igraph/build/src/io/parsers/dl-parser.c" 1872| 0| break; 1873| | 1874| 108| case 49: ------------------ | Branch (1874:3): [True: 108, False: 15.8M] ------------------ 1875| 108|#line 254 "/src/igraph/src/io/dl-parser.y" 1876| 108| {} 1877| 108|#line 1878 "/src/igraph/build/src/io/parsers/dl-parser.c" 1878| 108| break; 1879| | 1880| 56| case 50: ------------------ | Branch (1880:3): [True: 56, False: 15.8M] ------------------ 1881| 56|#line 256 "/src/igraph/src/io/dl-parser.y" 1882| 56| {} 1883| 56|#line 1884 "/src/igraph/build/src/io/parsers/dl-parser.c" 1884| 56| break; 1885| | 1886| 1| case 51: ------------------ | Branch (1886:3): [True: 1, False: 15.8M] ------------------ 1887| 1|#line 257 "/src/igraph/src/io/dl-parser.y" 1888| 1| {} 1889| 1|#line 1890 "/src/igraph/build/src/io/parsers/dl-parser.c" 1890| 1| break; 1891| | 1892| 34| case 52: ------------------ | Branch (1892:3): [True: 34, False: 15.8M] ------------------ 1893| 34|#line 258 "/src/igraph/src/io/dl-parser.y" 1894| 34| {} 1895| 34|#line 1896 "/src/igraph/build/src/io/parsers/dl-parser.c" 1896| 34| break; 1897| | 1898| 17| case 53: ------------------ | Branch (1898:3): [True: 17, False: 15.8M] ------------------ 1899| 17|#line 259 "/src/igraph/src/io/dl-parser.y" 1900| 17| {} 1901| 17|#line 1902 "/src/igraph/build/src/io/parsers/dl-parser.c" 1902| 17| break; 1903| | 1904| 0| case 54: ------------------ | Branch (1904:3): [True: 0, False: 15.8M] ------------------ 1905| 0|#line 260 "/src/igraph/src/io/dl-parser.y" 1906| 0| {} 1907| 0|#line 1908 "/src/igraph/build/src/io/parsers/dl-parser.c" 1908| 0| break; 1909| | 1910| 278| case 55: ------------------ | Branch (1910:3): [True: 278, False: 15.8M] ------------------ 1911| 278|#line 263 "/src/igraph/src/io/dl-parser.y" 1912| 278| {} 1913| 278|#line 1914 "/src/igraph/build/src/io/parsers/dl-parser.c" 1914| 278| break; 1915| | 1916| 462| case 56: ------------------ | Branch (1916:3): [True: 462, False: 15.8M] ------------------ 1917| 462|#line 264 "/src/igraph/src/io/dl-parser.y" 1918| 462| {} 1919| 462|#line 1920 "/src/igraph/build/src/io/parsers/dl-parser.c" 1920| 462| break; 1921| | 1922| 462| case 57: ------------------ | Branch (1922:3): [True: 462, False: 15.8M] ------------------ 1923| 462|#line 267 "/src/igraph/src/io/dl-parser.y" 1924| 462| {} 1925| 462|#line 1926 "/src/igraph/build/src/io/parsers/dl-parser.c" 1926| 462| break; 1927| | 1928| 683| case 58: ------------------ | Branch (1928:3): [True: 683, False: 15.8M] ------------------ 1929| 683|#line 269 "/src/igraph/src/io/dl-parser.y" 1930| 683| { 1931| 683| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 683| do { \ | | 11| 683| igraph_error_t igraph_i_ret = (expr); \ | | 12| 683| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 683| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 10, False: 673] | | | | ------------------ | | ------------------ | | 13| 10| context->igraph_errno = igraph_i_ret; \ | | 14| 10| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 10|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 10| YYABORT; \ | | ------------------ | | | | 784| 10|#define YYABORT goto yyabortlab | | ------------------ | | 16| 10| } \ | | 17| 683| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 673] | | ------------------ ------------------ 1932| 683| igraph_dl_yyget_leng(scanner), 1933| 683| &context->from)); 1934| 673| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(context->from)); ------------------ | | 10| 673| do { \ | | 11| 673| igraph_error_t igraph_i_ret = (expr); \ | | 12| 673| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 673| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 52, False: 621] | | | | ------------------ | | ------------------ | | 13| 52| context->igraph_errno = igraph_i_ret; \ | | 14| 52| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 52|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 52| YYABORT; \ | | ------------------ | | | | 784| 52|#define YYABORT goto yyabortlab | | ------------------ | | 16| 52| } \ | | 17| 673| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 621] | | ------------------ ------------------ 1935| 673|} 1936| 621|#line 1937 "/src/igraph/build/src/io/parsers/dl-parser.c" 1937| 621| break; 1938| | 1939| 621| case 59: ------------------ | Branch (1939:3): [True: 621, False: 15.8M] ------------------ 1940| 621|#line 276 "/src/igraph/src/io/dl-parser.y" 1941| 621| {} 1942| 621|#line 1943 "/src/igraph/build/src/io/parsers/dl-parser.c" 1943| 621| break; 1944| | 1945| 1.52M| case 60: ------------------ | Branch (1945:3): [True: 1.52M, False: 14.3M] ------------------ 1946| 1.52M|#line 276 "/src/igraph/src/io/dl-parser.y" 1947| 1.52M| { 1948| 1.52M| igraph_int_t to = (yyvsp[0].integer); 1949| 1.52M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 1.52M| do { \ | | 11| 1.52M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.52M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 53, False: 1.52M] | | | | ------------------ | | ------------------ | | 13| 53| context->igraph_errno = igraph_i_ret; \ | | 14| 53| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 53|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 53| YYABORT; \ | | ------------------ | | | | 784| 53|#define YYABORT goto yyabortlab | | ------------------ | | 16| 53| } \ | | 17| 1.52M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.52M] | | ------------------ ------------------ 1950| 1.52M| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 1.52M| do { \ | | 11| 1.52M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.52M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.52M] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 1.52M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.52M] | | ------------------ ------------------ 1951| 1.52M| context->from-1)); 1952| 1.52M| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, to-1)); ------------------ | | 10| 1.52M| do { \ | | 11| 1.52M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.52M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.52M] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 1.52M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.52M] | | ------------------ ------------------ 1953| 1.52M| } 1954| 1.52M|#line 1955 "/src/igraph/build/src/io/parsers/dl-parser.c" 1955| 1.52M| break; 1956| | 1957| 1.52M| case 61: ------------------ | Branch (1957:3): [True: 236, False: 15.8M] ------------------ 1958| 236|#line 284 "/src/igraph/src/io/dl-parser.y" 1959| 236| {} 1960| 236|#line 1961 "/src/igraph/build/src/io/parsers/dl-parser.c" 1961| 236| break; 1962| | 1963| 2.92k| case 62: ------------------ | Branch (1963:3): [True: 2.92k, False: 15.8M] ------------------ 1964| 2.92k|#line 285 "/src/igraph/src/io/dl-parser.y" 1965| 2.92k| {} 1966| 2.92k|#line 1967 "/src/igraph/build/src/io/parsers/dl-parser.c" 1967| 2.92k| break; 1968| | 1969| 2.92k| case 63: ------------------ | Branch (1969:3): [True: 2.92k, False: 15.8M] ------------------ 1970| 2.92k|#line 288 "/src/igraph/src/io/dl-parser.y" 1971| 2.92k| { } 1972| 2.92k|#line 1973 "/src/igraph/build/src/io/parsers/dl-parser.c" 1973| 2.92k| break; 1974| | 1975| 3.10k| case 64: ------------------ | Branch (1975:3): [True: 3.10k, False: 15.8M] ------------------ 1976| 3.10k|#line 290 "/src/igraph/src/io/dl-parser.y" 1977| 3.10k| { 1978| 3.10k| context->from=(yyvsp[0].integer); 1979| 3.10k| } 1980| 3.10k|#line 1981 "/src/igraph/build/src/io/parsers/dl-parser.c" 1981| 3.10k| break; 1982| | 1983| 3.73k| case 66: ------------------ | Branch (1983:3): [True: 3.73k, False: 15.8M] ------------------ 1984| 3.73k|#line 294 "/src/igraph/src/io/dl-parser.y" 1985| 3.73k| { 1986| 3.73k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 3.73k| do { \ | | 11| 3.73k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.73k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 3.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.73k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 3.73k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 3.73k] | | ------------------ ------------------ 1987| 3.73k| context->from)); 1988| 3.73k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, (yyvsp[0].integer))); ------------------ | | 10| 3.73k| do { \ | | 11| 3.73k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.73k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 3.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.73k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 3.73k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 3.73k] | | ------------------ ------------------ 1989| 3.73k| } 1990| 3.73k|#line 1991 "/src/igraph/build/src/io/parsers/dl-parser.c" 1991| 3.73k| break; 1992| | 1993| | 1994| 3.73k|#line 1995 "/src/igraph/build/src/io/parsers/dl-parser.c" 1995| | 1996| 1.66M| default: break; ------------------ | Branch (1996:7): [True: 1.66M, False: 14.1M] ------------------ 1997| 15.8M| } 1998| | /* User semantic actions sometimes alter yychar, and that requires 1999| | that yytoken be updated with the new translation. We take the 2000| | approach of translating immediately before every use of yytoken. 2001| | One alternative is translating here after every semantic action, 2002| | but that translation would be missed if the semantic action invokes 2003| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2004| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2005| | incorrect destructor might then be invoked immediately. In the 2006| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 2007| | to an incorrect destructor call or verbose syntax error message 2008| | before the lookahead is translated. */ 2009| 15.8M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2010| | 2011| 15.8M| YYPOPSTACK (yylen); ------------------ | | 1361| 15.8M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2012| 15.8M| yylen = 0; 2013| 15.8M| YY_STACK_PRINT (yyss, yyssp); 2014| | 2015| 15.8M| *++yyvsp = yyval; 2016| 15.8M| *++yylsp = yyloc; 2017| | 2018| | /* Now 'shift' the result of the reduction. Determine what state 2019| | that goes to, based on the state we popped back to and the rule 2020| | number reduced by. */ 2021| 15.8M| { 2022| 15.8M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 532| 15.8M|#define YYNTOKENS 17 ------------------ 2023| 15.8M| const int yyi = yypgoto[yylhs] + *yyssp; 2024| 15.8M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 529| 26.6M|#define YYLAST 118 ------------------ | Branch (2024:16): [True: 10.8M, False: 5.02M] | Branch (2024:28): [True: 10.8M, False: 196] | Branch (2024:45): [True: 6.05M, False: 4.77M] ------------------ 2025| 15.8M| ? yytable[yyi] 2026| 15.8M| : yydefgoto[yylhs]); 2027| 15.8M| } 2028| | 2029| 15.8M| goto yynewstate; 2030| | 2031| | 2032| |/*--------------------------------------. 2033| || yyerrlab -- here on detecting error. | 2034| |`--------------------------------------*/ 2035| 816|yyerrlab: 2036| | /* Make sure we have latest lookahead translation. See comments at 2037| | user semantic actions for why this is necessary. */ 2038| 816| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 816|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 547| 1.63k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 816|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 816, False: 0] | | | Branch (547:18): [True: 816, False: 0] | | ------------------ ------------------ | Branch (2038:13): [True: 0, False: 816] ------------------ 2039| | 2040| | /* If not already recovering from an error, report this error. */ 2041| 816| if (!yyerrstatus) ------------------ | Branch (2041:7): [True: 816, False: 0] ------------------ 2042| 816| { 2043| 816| ++yynerrs; ------------------ | | 71| 816|#define yynerrs igraph_dl_yynerrs ------------------ 2044| |#if ! YYERROR_VERBOSE 2045| | yyerror (&yylloc, context, YY_("syntax error")); 2046| |#else 2047| 816|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2048| 816| yyssp, yytoken) 2049| 816| { 2050| 816| char const *yymsgp = YY_("syntax error"); ------------------ | | 334| 816|# define YY_(Msgid) Msgid ------------------ 2051| 816| int yysyntax_error_status; 2052| 816| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 2047| 816|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 2048| 816| yyssp, yytoken) ------------------ 2053| 816| if (yysyntax_error_status == 0) ------------------ | Branch (2053:13): [True: 816, False: 0] ------------------ 2054| 816| yymsgp = yymsg; 2055| 0| else if (yysyntax_error_status == 1) ------------------ | Branch (2055:18): [True: 0, False: 0] ------------------ 2056| 0| { 2057| 0| if (yymsg != yymsgbuf) ------------------ | Branch (2057:17): [True: 0, False: 0] ------------------ 2058| 0| YYSTACK_FREE (yymsg); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2059| 0| yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); ------------------ | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2060| 0| if (!yymsg) ------------------ | Branch (2060:17): [True: 0, False: 0] ------------------ 2061| 0| { 2062| 0| yymsg = yymsgbuf; 2063| 0| yymsg_alloc = sizeof yymsgbuf; 2064| 0| yysyntax_error_status = 2; 2065| 0| } 2066| 0| else 2067| 0| { 2068| 0| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 2047| 0|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 2048| 0| yyssp, yytoken) ------------------ 2069| 0| yymsgp = yymsg; 2070| 0| } 2071| 0| } 2072| 816| yyerror (&yylloc, context, yymsgp); ------------------ | | 69| 816|#define yyerror igraph_dl_yyerror ------------------ 2073| 816| if (yysyntax_error_status == 2) ------------------ | Branch (2073:13): [True: 0, False: 816] ------------------ 2074| 0| goto yyexhaustedlab; 2075| 816| } 2076| 816|# undef YYSYNTAX_ERROR 2077| 816|#endif 2078| 816| } 2079| | 2080| 816| yyerror_range[1] = yylloc; 2081| | 2082| 816| if (yyerrstatus == 3) ------------------ | Branch (2082:7): [True: 0, False: 816] ------------------ 2083| 0| { 2084| | /* If just tried and failed to reuse lookahead token after an 2085| | error, discard it. */ 2086| | 2087| 0| if (yychar <= YYEOF) ------------------ | | 781| 0|#define YYEOF 0 ------------------ | Branch (2087:11): [True: 0, False: 0] ------------------ 2088| 0| { 2089| | /* Return failure if at end of input. */ 2090| 0| if (yychar == YYEOF) ------------------ | | 781| 0|#define YYEOF 0 ------------------ | Branch (2090:15): [True: 0, False: 0] ------------------ 2091| 0| YYABORT; ------------------ | | 784| 0|#define YYABORT goto yyabortlab ------------------ 2092| 0| } 2093| 0| else 2094| 0| { 2095| 0| yydestruct ("Error: discarding", 2096| 0| yytoken, &yylval, &yylloc, context); 2097| 0| yychar = YYEMPTY; ------------------ | | 780| 0|#define YYEMPTY (-2) ------------------ 2098| 0| } 2099| 0| } 2100| | 2101| | /* Else will try to reuse lookahead token after shifting the error 2102| | token. */ 2103| 816| goto yyerrlab1; 2104| | 2105| | 2106| |/*---------------------------------------------------. 2107| || yyerrorlab -- error raised explicitly by YYERROR. | 2108| |`---------------------------------------------------*/ 2109| 816|yyerrorlab: 2110| | /* Pacify compilers when the user code never invokes YYERROR and the 2111| | label yyerrorlab therefore never appears in user code. */ 2112| 0| if (0) ------------------ | Branch (2112:7): [Folded, False: 0] ------------------ 2113| 0| YYERROR; ------------------ | | 785| 0|#define YYERROR goto yyerrorlab ------------------ 2114| | 2115| | /* Do not reclaim the symbols of the rule whose action triggered 2116| | this YYERROR. */ 2117| 0| YYPOPSTACK (yylen); ------------------ | | 1361| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2118| 0| yylen = 0; 2119| 0| YY_STACK_PRINT (yyss, yyssp); 2120| 0| yystate = *yyssp; 2121| 0| goto yyerrlab1; 2122| | 2123| | 2124| |/*-------------------------------------------------------------. 2125| || yyerrlab1 -- common code for both syntax error and YYERROR. | 2126| |`-------------------------------------------------------------*/ 2127| 816|yyerrlab1: 2128| 816| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2129| | 2130| 816| for (;;) 2131| 7.84k| { 2132| 7.84k| yyn = yypact[yystate]; 2133| 7.84k| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 7.84k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 7.84k|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (2133:11): [True: 6.84k, False: 996] ------------------ 2134| 6.84k| { 2135| 6.84k| yyn += YYTERROR; ------------------ | | 808| 6.84k|#define YYTERROR 1 ------------------ 2136| 6.84k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 529| 13.6k|#define YYLAST 118 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 808| 6.84k|#define YYTERROR 1 ------------------ | Branch (2136:15): [True: 6.84k, False: 0] | Branch (2136:27): [True: 6.84k, False: 0] | Branch (2136:44): [True: 0, False: 6.84k] ------------------ 2137| 0| { 2138| 0| yyn = yytable[yyn]; 2139| 0| if (0 < yyn) ------------------ | Branch (2139:19): [True: 0, False: 0] ------------------ 2140| 0| break; 2141| 0| } 2142| 6.84k| } 2143| | 2144| | /* Pop the current state because it cannot handle the error token. */ 2145| 7.84k| if (yyssp == yyss) ------------------ | Branch (2145:11): [True: 816, False: 7.02k] ------------------ 2146| 816| YYABORT; ------------------ | | 784| 816|#define YYABORT goto yyabortlab ------------------ 2147| | 2148| 7.02k| yyerror_range[1] = *yylsp; 2149| 7.02k| yydestruct ("Error: popping", 2150| 7.02k| yystos[yystate], yyvsp, yylsp, context); 2151| 7.02k| YYPOPSTACK (1); ------------------ | | 1361| 7.02k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2152| 7.02k| yystate = *yyssp; 2153| 7.02k| YY_STACK_PRINT (yyss, yyssp); 2154| 7.02k| } 2155| | 2156| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2157| 0| *++yyvsp = yylval; 2158| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 2159| | 2160| 0| yyerror_range[2] = yylloc; 2161| | /* Using YYLLOC is tempting, but would change the location of 2162| | the lookahead. YYLOC is available though. */ 2163| 0| YYLLOC_DEFAULT (yyloc, yyerror_range, 2); ------------------ | | 818| 0| do \ | | 819| 0| if (N) \ | | ------------------ | | | Branch (819:11): [True: 0, Folded] | | ------------------ | | 820| 0| { \ | | 821| 0| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 836| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 822| 0| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 836| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 823| 0| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 836| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 824| 0| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 836| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 825| 0| } \ | | 826| 0| else \ | | 827| 0| { \ | | 828| 0| (Current).first_line = (Current).last_line = \ | | 829| 0| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 836| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 830| 0| (Current).first_column = (Current).last_column = \ | | 831| 0| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 836| 0|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 832| 0| } \ | | 833| 0| while (0) | | ------------------ | | | Branch (833:12): [Folded, False: 0] | | ------------------ ------------------ 2164| 0| *++yylsp = yyloc; 2165| | 2166| | /* Shift the error token. */ 2167| 0| YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2168| | 2169| 0| yystate = yyn; 2170| 0| goto yynewstate; 2171| | 2172| | 2173| |/*-------------------------------------. 2174| || yyacceptlab -- YYACCEPT comes here. | 2175| |`-------------------------------------*/ 2176| 827|yyacceptlab: 2177| 827| yyresult = 0; 2178| 827| goto yyreturn; 2179| | 2180| | 2181| |/*-----------------------------------. 2182| || yyabortlab -- YYABORT comes here. | 2183| |`-----------------------------------*/ 2184| 1.49k|yyabortlab: 2185| 1.49k| yyresult = 1; 2186| 1.49k| goto yyreturn; 2187| | 2188| | 2189| 0|#if !defined yyoverflow || YYERROR_VERBOSE 2190| |/*-------------------------------------------------. 2191| || yyexhaustedlab -- memory exhaustion comes here. | 2192| |`-------------------------------------------------*/ 2193| 0|yyexhaustedlab: 2194| 0| yyerror (&yylloc, context, YY_("memory exhausted")); ------------------ | | 69| 0|#define yyerror igraph_dl_yyerror ------------------ yyerror (&yylloc, context, YY_("memory exhausted")); ------------------ | | 334| 0|# define YY_(Msgid) Msgid ------------------ 2195| 0| yyresult = 2; 2196| | /* Fall through. */ 2197| 0|#endif 2198| | 2199| | 2200| |/*-----------------------------------------------------. 2201| || yyreturn -- parsing is finished, return the result. | 2202| |`-----------------------------------------------------*/ 2203| 2.32k|yyreturn: 2204| 2.32k| if (yychar != YYEMPTY) ------------------ | | 780| 2.32k|#define YYEMPTY (-2) ------------------ | Branch (2204:7): [True: 816, False: 1.50k] ------------------ 2205| 816| { 2206| | /* Make sure we have latest lookahead translation. See comments at 2207| | user semantic actions for why this is necessary. */ 2208| 816| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 816| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 816|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 816, False: 0] | | | Branch (547:18): [True: 816, False: 0] | | ------------------ ------------------ 2209| 816| yydestruct ("Cleanup: discarding lookahead", 2210| 816| yytoken, &yylval, &yylloc, context); 2211| 816| } 2212| | /* Do not reclaim the symbols of the rule whose action triggered 2213| | this YYABORT or YYACCEPT. */ 2214| 2.32k| YYPOPSTACK (yylen); ------------------ | | 1361| 2.32k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2215| 2.32k| YY_STACK_PRINT (yyss, yyssp); 2216| 9.41k| while (yyssp != yyss) ------------------ | Branch (2216:10): [True: 7.09k, False: 2.32k] ------------------ 2217| 7.09k| { 2218| 7.09k| yydestruct ("Cleanup: popping", 2219| 7.09k| yystos[+*yyssp], yyvsp, yylsp, context); 2220| 7.09k| YYPOPSTACK (1); ------------------ | | 1361| 7.09k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2221| 7.09k| } 2222| 2.32k|#ifndef yyoverflow 2223| 2.32k| if (yyss != yyssa) ------------------ | Branch (2223:7): [True: 0, False: 2.32k] ------------------ 2224| 0| YYSTACK_FREE (yyss); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2225| 2.32k|#endif 2226| 2.32k|#if YYERROR_VERBOSE 2227| 2.32k| if (yymsg != yymsgbuf) ------------------ | Branch (2227:7): [True: 0, False: 2.32k] ------------------ 2228| 0| YYSTACK_FREE (yymsg); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2229| 2.32k|#endif 2230| 2.32k| return yyresult; 2231| 0|} igraph_dl_yyerror: 2237| 1.44k| const char *s) { 2238| 1.44k| snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1, 2239| 1.44k| "Parse error in DL file, line %i (%s)", 2240| 1.44k| locp->first_line, s); 2241| 1.44k| return 0; 2242| 1.44k|} dl-parser.c:yysyntax_error: 1131| 816|{ 1132| 816| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1133| | /* Internationalized format string. */ 1134| 816| const char *yyformat = YY_NULLPTR; ------------------ | | 138| 816|# define YY_NULLPTR ((void*)0) ------------------ 1135| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1136| | one per "expected"). */ 1137| 816| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1138| | /* Actual size of YYARG. */ 1139| 816| int yycount = 0; 1140| | /* Cumulated lengths of YYARG. */ 1141| 816| YYPTRDIFF_T yysize = 0; ------------------ | | 285| 816|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1142| | 1143| | /* There are many possibilities here to consider: 1144| | - If this state is a consistent state with a default action, then 1145| | the only way this function was invoked is if the default action 1146| | is an error action. In that case, don't check for expected 1147| | tokens because there are none. 1148| | - The only way there can be no lookahead present (in yychar) is if 1149| | this state is a consistent state with a default action. Thus, 1150| | detecting the absence of a lookahead is sufficient to determine 1151| | that there is no unexpected or expected token to report. In that 1152| | case, just report a simple "syntax error". 1153| | - Don't assume there isn't a lookahead just because this state is a 1154| | consistent state with a default action. There might have been a 1155| | previous inconsistent state, consistent state with a non-default 1156| | action, or user semantic action that manipulated yychar. 1157| | - Of course, the expected token list depends on states to have 1158| | correct lookahead information, and it depends on the parser not 1159| | to perform extra reductions after fetching a lookahead from the 1160| | scanner and before detecting a syntax error. Thus, state merging 1161| | (from LALR or IELR) and default reductions corrupt the expected 1162| | token list. However, the list is correct for canonical LR with 1163| | one exception: it will still contain any token that will not be 1164| | accepted due to an error action in a later state. 1165| | */ 1166| 816| if (yytoken != YYEMPTY) ------------------ | | 780| 816|#define YYEMPTY (-2) ------------------ | Branch (1166:7): [True: 816, False: 0] ------------------ 1167| 816| { 1168| 816| int yyn = yypact[+*yyssp]; 1169| 816| YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 285| 816|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 138| 816|# define YY_NULLPTR ((void*)0) ------------------ 1170| 816| yysize = yysize0; 1171| 816| yyarg[yycount++] = yytname[yytoken]; 1172| 816| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 816| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 816|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (1172:11): [True: 816, False: 0] ------------------ 1173| 816| { 1174| | /* Start YYX at -YYN if negative to avoid negative indexes in 1175| | YYCHECK. In other words, skip the first -YYN actions for 1176| | this state because they are default actions. */ 1177| 816| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1177:26): [True: 0, False: 816] ------------------ 1178| | /* Stay within bounds of both yycheck and yytname. */ 1179| 816| int yychecklim = YYLAST - yyn + 1; ------------------ | | 529| 816|#define YYLAST 118 ------------------ 1180| 816| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 816|#define YYNTOKENS 17 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 816|#define YYNTOKENS 17 ------------------ | Branch (1180:24): [True: 0, False: 816] ------------------ 1181| 816| int yyx; 1182| | 1183| 14.6k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1183:32): [True: 13.8k, False: 807] ------------------ 1184| 13.8k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 808| 15.1k|#define YYTERROR 1 ------------------ | Branch (1184:17): [True: 1.31k, False: 12.5k] | Branch (1184:46): [True: 1.31k, False: 0] ------------------ 1185| 0| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 637| 0| 0 ------------------ | Branch (1185:20): [True: 0, Folded] ------------------ 1186| 1.31k| { 1187| 1.31k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1187:21): [True: 9, False: 1.30k] ------------------ 1188| 9| { 1189| 9| yycount = 1; 1190| 9| yysize = yysize0; 1191| 9| break; 1192| 9| } 1193| 1.30k| yyarg[yycount++] = yytname[yyx]; 1194| 1.30k| { 1195| 1.30k| YYPTRDIFF_T yysize1 ------------------ | | 285| 1.30k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1196| 1.30k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 138| 1.30k|# define YY_NULLPTR ((void*)0) ------------------ 1197| 1.30k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 1.30k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 1.30k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 2.60k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 1.30k, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1197:23): [True: 1.30k, False: 0] | Branch (1197:44): [True: 1.30k, False: 0] ------------------ 1198| 1.30k| yysize = yysize1; 1199| 0| else 1200| 0| return 2; 1201| 1.30k| } 1202| 1.30k| } 1203| 816| } 1204| 816| } 1205| | 1206| 816| switch (yycount) 1207| 816| { 1208| 0|# define YYCASE_(N, S) \ 1209| 0| case N: \ 1210| 0| yyformat = S; \ 1211| 0| break 1212| 0| default: /* Avoid compiler warnings. */ ------------------ | Branch (1212:5): [True: 0, False: 816] ------------------ 1213| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1209| 0| case N: \ | | ------------------ | | | Branch (1209:7): [True: 0, False: 816] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1214| 9| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1209| 9| case N: \ | | ------------------ | | | Branch (1209:7): [True: 9, False: 807] | | ------------------ | | 1210| 9| yyformat = S; \ | | 1211| 9| break ------------------ 1215| 375| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1209| 375| case N: \ | | ------------------ | | | Branch (1209:7): [True: 375, False: 441] | | ------------------ | | 1210| 375| yyformat = S; \ | | 1211| 375| break ------------------ 1216| 406| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1209| 406| case N: \ | | ------------------ | | | Branch (1209:7): [True: 406, False: 410] | | ------------------ | | 1210| 406| yyformat = S; \ | | 1211| 406| break ------------------ 1217| 26| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1209| 26| case N: \ | | ------------------ | | | Branch (1209:7): [True: 26, False: 790] | | ------------------ | | 1210| 26| yyformat = S; \ | | 1211| 26| break ------------------ 1218| 816| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1209| 0| case N: \ | | ------------------ | | | Branch (1209:7): [True: 0, False: 816] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1219| 816|# undef YYCASE_ 1220| 816| } 1221| | 1222| 816| { 1223| | /* Don't count the "%s"s in the final size, but reserve room for 1224| | the terminator. */ 1225| 816| YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 285| 816|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 1035| 816|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 816|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1226| 816| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 816|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 816| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 1.63k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 816, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1226:9): [True: 816, False: 0] | Branch (1226:30): [True: 816, False: 0] ------------------ 1227| 816| yysize = yysize1; 1228| 0| else 1229| 0| return 2; 1230| 816| } 1231| | 1232| 816| if (*yymsg_alloc < yysize) ------------------ | Branch (1232:7): [True: 0, False: 816] ------------------ 1233| 0| { 1234| 0| *yymsg_alloc = 2 * yysize; 1235| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (1235:14): [True: 0, False: 0] ------------------ 1236| 0| && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 437| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 0, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1236:17): [True: 0, False: 0] ------------------ 1237| 0| *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ------------------ | | 437| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 0, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1238| 0| return 1; 1239| 0| } 1240| | 1241| | /* Avoid sprintf, as that infringes on the user's name space. 1242| | Don't have undefined behavior even if the translation 1243| | produced a string with the wrong number of "%s"s. */ 1244| 816| { 1245| 816| char *yyp = *yymsg; 1246| 816| int yyi = 0; 1247| 34.8k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1247:12): [True: 33.9k, False: 816] ------------------ 1248| 33.9k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1248:11): [True: 2.08k, False: 31.9k] | Branch (1248:26): [True: 2.08k, False: 0] | Branch (1248:48): [True: 2.08k, False: 0] ------------------ 1249| 2.08k| { 1250| 2.08k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1251| 2.08k| yyformat += 2; 1252| 2.08k| } 1253| 31.9k| else 1254| 31.9k| { 1255| 31.9k| ++yyp; 1256| 31.9k| ++yyformat; 1257| 31.9k| } 1258| 816| } 1259| 816| return 0; 1260| 816|} dl-parser.c:yytnamerr: 1079| 4.19k|{ 1080| 4.19k| if (*yystr == '"') ------------------ | Branch (1080:7): [True: 3.03k, False: 1.16k] ------------------ 1081| 3.03k| { 1082| 3.03k| YYPTRDIFF_T yyn = 0; ------------------ | | 285| 3.03k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1083| 3.03k| char const *yyp = yystr; 1084| | 1085| 3.03k| for (;;) 1086| 26.0k| switch (*++yyp) 1087| 26.0k| { 1088| 0| case '\'': ------------------ | Branch (1088:11): [True: 0, False: 26.0k] ------------------ 1089| 0| case ',': ------------------ | Branch (1089:11): [True: 0, False: 26.0k] ------------------ 1090| 0| goto do_not_strip_quotes; 1091| | 1092| 0| case '\\': ------------------ | Branch (1092:11): [True: 0, False: 26.0k] ------------------ 1093| 0| if (*++yyp != '\\') ------------------ | Branch (1093:17): [True: 0, False: 0] ------------------ 1094| 0| goto do_not_strip_quotes; 1095| 0| else 1096| 0| goto append; 1097| | 1098| 0| append: 1099| 22.9k| default: ------------------ | Branch (1099:11): [True: 22.9k, False: 3.03k] ------------------ 1100| 22.9k| if (yyres) ------------------ | Branch (1100:17): [True: 11.3k, False: 11.6k] ------------------ 1101| 11.3k| yyres[yyn] = *yyp; 1102| 22.9k| yyn++; 1103| 22.9k| break; 1104| | 1105| 3.03k| case '"': ------------------ | Branch (1105:11): [True: 3.03k, False: 22.9k] ------------------ 1106| 3.03k| if (yyres) ------------------ | Branch (1106:17): [True: 1.50k, False: 1.53k] ------------------ 1107| 1.50k| yyres[yyn] = '\0'; 1108| 3.03k| return yyn; 1109| 26.0k| } 1110| 0| do_not_strip_quotes: ; 1111| 0| } 1112| | 1113| 1.16k| if (yyres) ------------------ | Branch (1113:7): [True: 578, False: 587] ------------------ 1114| 578| return yystpcpy (yyres, yystr) - yyres; 1115| 587| else 1116| 587| return yystrlen (yystr); ------------------ | | 1035| 587|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 587|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1117| 1.16k|} dl-parser.c:yystpcpy: 1057| 578|{ 1058| 578| char *yyd = yydest; 1059| 578| const char *yys = yysrc; 1060| | 1061| 3.10k| while ((*yyd++ = *yys++) != '\0') ------------------ | Branch (1061:10): [True: 2.52k, False: 578] ------------------ 1062| 2.52k| continue; 1063| | 1064| 578| return yyd - 1; 1065| 578|} dl-parser.c:yydestruct: 1269| 14.9k|{ 1270| 14.9k| YYUSE (yyvaluep); ------------------ | | 356| 14.9k|# define YYUSE(E) ((void) (E)) ------------------ 1271| 14.9k| YYUSE (yylocationp); ------------------ | | 356| 14.9k|# define YYUSE(E) ((void) (E)) ------------------ 1272| 14.9k| YYUSE (context); ------------------ | | 356| 14.9k|# define YYUSE(E) ((void) (E)) ------------------ 1273| 14.9k| if (!yymsg) ------------------ | Branch (1273:7): [True: 0, False: 14.9k] ------------------ 1274| 0| yymsg = "Deleting"; 1275| 14.9k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1276| | 1277| 14.9k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1278| 14.9k| YYUSE (yytype); ------------------ | | 356| 14.9k|# define YYUSE(E) ((void) (E)) ------------------ 1279| 14.9k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1280| 14.9k|} dl-parser.c:igraph_i_dl_add_str: 2245| 1.63M| igraph_i_dl_parsedata_t *context) { 2246| 1.63M| IGRAPH_CHECK(igraph_strvector_push_back_len(&context->labels, newstr, length)); ------------------ | | 656| 1.63M| do { \ | | 657| 1.63M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.63M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.63M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.63M] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 1.63M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.63M] | | ------------------ ------------------ 2247| 1.63M| return IGRAPH_SUCCESS; 2248| 1.63M|} dl-parser.c:igraph_i_dl_add_edge: 2251| 2.32M| igraph_i_dl_parsedata_t *context) { 2252| | //IGRAPH_CHECK(igraph_i_dl_check_vid(from+1)); 2253| | //IGRAPH_CHECK(igraph_i_dl_check_vid(to+1)); 2254| 2.32M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, from)); ------------------ | | 656| 2.32M| do { \ | | 657| 2.32M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.32M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.32M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.32M] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 2.32M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.32M] | | ------------------ ------------------ 2255| 2.32M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, to)); ------------------ | | 656| 2.32M| do { \ | | 657| 2.32M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.32M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.32M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.32M] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 2.32M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.32M] | | ------------------ ------------------ 2256| 2.32M| return IGRAPH_SUCCESS; 2257| 2.32M|} dl-parser.c:igraph_i_dl_add_edge_w: 2261| 34.3k| igraph_i_dl_parsedata_t *context) { 2262| 34.3k| igraph_int_t n=igraph_vector_size(&context->weights); 2263| 34.3k| igraph_int_t n2=igraph_vector_int_size(&context->edges)/2; 2264| 34.3k| if (n != n2) { ------------------ | Branch (2264:7): [True: 32.4k, False: 1.88k] ------------------ 2265| 32.4k| IGRAPH_CHECK(igraph_vector_resize(&context->weights, n2)); ------------------ | | 656| 32.4k| do { \ | | 657| 32.4k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 32.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 32.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 32.4k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 32.4k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 32.4k] | | ------------------ ------------------ 2266| 2.31M| for (; nweights)[n]=IGRAPH_NAN; ------------------ | | 60| 2.28M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context->weights)[n]=IGRAPH_NAN; ------------------ | | 138| 2.28M|#define IGRAPH_NAN ((double)NAN) ------------------ 2268| 2.28M| } 2269| 32.4k| } 2270| 34.3k| IGRAPH_CHECK(igraph_i_dl_add_edge(from, to, context)); ------------------ | | 656| 34.3k| do { \ | | 657| 34.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 34.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 34.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 34.3k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 34.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 34.3k] | | ------------------ ------------------ 2271| 34.3k| IGRAPH_CHECK(igraph_vector_push_back(&context->weights, weight)); ------------------ | | 656| 34.3k| do { \ | | 657| 34.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 34.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 34.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 34.3k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 34.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 34.3k] | | ------------------ ------------------ 2272| 34.3k| return IGRAPH_SUCCESS; 2273| 34.3k|} dl-parser.c:igraph_i_dl_check_vid: 2277| 6.18M|static igraph_error_t igraph_i_dl_check_vid(igraph_int_t dl_vid) { 2278| 6.18M| if (dl_vid < 1) { ------------------ | Branch (2278:9): [True: 315, False: 6.18M] ------------------ 2279| 315| IGRAPH_ERRORF("Invalid vertex index in DL file: %" IGRAPH_PRId ".", ------------------ | | 464| 315| do { \ | | 465| 315| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 315| igraph_errno, __VA_ARGS__) ; \ | | 467| 315| return igraph_errno; \ | | 468| 315| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 2280| 315| IGRAPH_EINVAL, dl_vid); 2281| 315| } 2282| 6.18M| if (dl_vid > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 6.18M|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (2282:9): [True: 240, False: 6.18M] ------------------ 2283| 240| IGRAPH_ERRORF("Vertex index too large in DL file: %" IGRAPH_PRId ".", ------------------ | | 464| 240| do { \ | | 465| 240| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 240| igraph_errno, __VA_ARGS__) ; \ | | 467| 240| return igraph_errno; \ | | 468| 240| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 2284| 240| IGRAPH_EINVAL, dl_vid); 2285| 240| } 2286| 6.18M| return IGRAPH_SUCCESS; 2287| 6.18M|} LLVMFuzzerTestOneInput: 25| 2.32k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 26| | 27| 2.32k| igraph_set_error_handler(igraph_error_handler_ignore); 28| 2.32k| igraph_set_warning_handler(igraph_warning_handler_ignore); 29| | 30| | // Turn on attribute handling 31| 2.32k| igraph_set_attribute_table(&igraph_cattribute_table); 32| | 33| | // Read input file 34| 2.32k| FILE *ifile = fmemopen((void*) data, size, "r"); 35| 2.32k| if (!ifile) { ------------------ | Branch (35:9): [True: 0, False: 2.32k] ------------------ 36| 0| return 0; 37| 0| } 38| | 39| | // Do the fuzzing 40| 2.32k| igraph_t g; 41| 2.32k| if (igraph_read_graph_dl(&g, ifile, IGRAPH_DIRECTED) == IGRAPH_SUCCESS) { ------------------ | Branch (41:9): [True: 498, False: 1.82k] ------------------ 42| | // Clean up 43| 498| igraph_destroy(&g); 44| 498| } 45| | 46| | // no need to call igraph_destroy() if igraph_read_graph_dl() returns an 47| | // error code as we don't have a valid graph object in that case 48| | 49| 2.32k| fclose(ifile); 50| | 51| 2.32k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY); ------------------ | | 924| 2.32k| do { \ | | 925| 2.32k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | ------------------ | | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__ | | ------------------ | | 927| 0| } \ | | 928| 2.32k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.32k] | | ------------------ ------------------ 52| | 53| 2.32k| return 0; 54| 2.32k|} igraph_error: 210| 2.96k| igraph_error_t igraph_errno) { 211| | 212| 2.96k| if (igraph_i_error_handler) { ------------------ | Branch (212:9): [True: 2.96k, False: 0] ------------------ 213| 2.96k| igraph_i_error_handler(reason, file, line, igraph_errno); 214| 2.96k|#ifndef USING_R 215| 2.96k| } else { 216| 0| igraph_error_handler_abort(reason, file, line, igraph_errno); 217| 0|#endif 218| 0| } 219| 2.96k| return igraph_errno; 220| 2.96k|} igraph_errorf: 240| 610| igraph_error_t igraph_errno, ...) { 241| 610| va_list ap; 242| 610| va_start(ap, igraph_errno); 243| 610| vsnprintf(igraph_i_errormsg_buffer, 244| 610| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap); 245| | va_end(ap); 246| 610| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno); 247| 610|} igraph_error_handler_ignore: 266| 2.96k| int line, igraph_error_t igraph_errno) { 267| 2.96k| IGRAPH_UNUSED(reason); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 268| 2.96k| IGRAPH_UNUSED(file); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 269| 2.96k| IGRAPH_UNUSED(line); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 270| 2.96k| IGRAPH_UNUSED(igraph_errno); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 271| | 272| 2.96k| IGRAPH_FINALLY_FREE(); 273| 2.96k|} igraph_set_error_handler: 298| 2.32k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) { 299| 2.32k| igraph_error_handler_t *previous_handler = igraph_i_error_handler; 300| 2.32k| igraph_i_error_handler = new_handler; 301| 2.32k| return previous_handler; 302| 2.32k|} IGRAPH_FINALLY_REAL: 320| 85.5k|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) { 321| 85.5k| int no = igraph_i_finally_stack_size; 322| 85.5k| if (no < 0) { ------------------ | Branch (322:9): [True: 0, False: 85.5k] ------------------ 323| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 324| 0| igraph_i_reset_finally_stack(); 325| 0| IGRAPH_FATALF("Corrupt finally stack: it contains %d elements.", no); ------------------ | | 875| 0| do { \ | | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 877| 0| __VA_ARGS__); \ | | 878| 0| } while (0) | | ------------------ | | | Branch (878:14): [Folded, False: 0] | | ------------------ ------------------ 326| 0| } 327| 85.5k| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) { ------------------ | Branch (327:9): [True: 0, False: 85.5k] ------------------ 328| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 329| 0| igraph_i_reset_finally_stack(); 330| 0| IGRAPH_FATALF("Finally stack too large: it contains %d elements.", no); ------------------ | | 875| 0| do { \ | | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 877| 0| __VA_ARGS__); \ | | 878| 0| } while (0) | | ------------------ | | | Branch (878:14): [Folded, False: 0] | | ------------------ ------------------ 331| 0| } 332| 85.5k| igraph_i_finally_stack[no].ptr = ptr; 333| 85.5k| igraph_i_finally_stack[no].func = func; 334| 85.5k| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level; 335| 85.5k| igraph_i_finally_stack_size++; 336| 85.5k|} IGRAPH_FINALLY_CLEAN: 338| 27.2k|void IGRAPH_FINALLY_CLEAN(int minus) { 339| 27.2k| igraph_i_finally_stack_size -= minus; 340| 27.2k| if (igraph_i_finally_stack_size < 0) { ------------------ | Branch (340:9): [True: 0, False: 27.2k] ------------------ 341| 0| int left = igraph_i_finally_stack_size + minus; 342| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 343| 0| igraph_i_reset_finally_stack(); 344| 0| IGRAPH_FATALF("Corrupt finally stack: trying to pop %d element(s) when only %d left.", minus, left); ------------------ | | 875| 0| do { \ | | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 877| 0| __VA_ARGS__); \ | | 878| 0| } while (0) | | ------------------ | | | Branch (878:14): [Folded, False: 0] | | ------------------ ------------------ 345| 0| } 346| 27.2k|} IGRAPH_FINALLY_FREE: 348| 2.96k|void IGRAPH_FINALLY_FREE(void) { 349| 12.6k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) { ------------------ | Branch (349:12): [True: 10.5k, False: 2.15k] ------------------ 350| 10.5k| int p = igraph_i_finally_stack_size - 1; 351| | /* Call destructors only up to the current level */ 352| 10.5k| if (igraph_i_finally_stack[p].level < igraph_i_finally_stack_level) { ------------------ | Branch (352:13): [True: 814, False: 9.69k] ------------------ 353| 814| break; 354| 814| } 355| 9.69k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr); 356| 9.69k| } 357| 2.96k|} IGRAPH_FINALLY_STACK_SIZE: 359| 2.32k|int IGRAPH_FINALLY_STACK_SIZE(void) { 360| 2.32k| return igraph_i_finally_stack_size; 361| 2.32k|} IGRAPH_FINALLY_ENTER: 377| 554k|void IGRAPH_FINALLY_ENTER(void) { 378| 554k| int no = igraph_i_finally_stack_size; 379| | /* Level indices must always be in increasing order in the finally stack */ 380| 554k| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) { ------------------ | Branch (380:9): [True: 554k, False: 0] | Branch (380:19): [True: 0, False: 554k] ------------------ 381| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 382| 0| igraph_i_reset_finally_stack(); 383| 0| IGRAPH_FATAL("Corrupt finally stack: cannot create new finally stack level before last one is freed."); ------------------ | | 895| 0| do { \ | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 897| 0| } while (0) | | ------------------ | | | Branch (897:14): [Folded, False: 0] | | ------------------ ------------------ 384| 0| } 385| 554k| igraph_i_finally_stack_level++; 386| 554k|} IGRAPH_FINALLY_EXIT: 399| 554k|void IGRAPH_FINALLY_EXIT(void) { 400| 554k| igraph_i_finally_stack_level--; 401| 554k| if (igraph_i_finally_stack_level < 0) { ------------------ | Branch (401:9): [True: 0, False: 554k] ------------------ 402| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 403| 0| igraph_i_reset_finally_stack(); 404| 0| IGRAPH_FATAL("Corrupt finally stack: trying to exit outermost finally stack level."); ------------------ | | 895| 0| do { \ | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 897| 0| } while (0) | | ------------------ | | | Branch (897:14): [Folded, False: 0] | | ------------------ ------------------ 405| 0| } 406| 554k|} igraph_warning_handler_ignore: 424| 304|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) { 425| 304| IGRAPH_UNUSED(reason); ------------------ | | 30| 304|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 426| 304| IGRAPH_UNUSED(file); ------------------ | | 30| 304|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 427| 304| IGRAPH_UNUSED(line); ------------------ | | 30| 304|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 428| 304|} igraph_warning: 463| 304|void igraph_warning(const char *reason, const char *file, int line) { 464| | 465| 304| if (igraph_i_warning_handler) { ------------------ | Branch (465:9): [True: 304, False: 0] ------------------ 466| 304| igraph_i_warning_handler(reason, file, line); 467| 304|#ifndef USING_R 468| 304| } else { 469| 0| igraph_warning_handler_print(reason, file, line); 470| 0|#endif 471| 0| } 472| 304|} igraph_set_warning_handler: 514| 2.32k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) { 515| 2.32k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler; 516| 2.32k| igraph_i_warning_handler = new_handler; 517| 2.32k| return previous_handler; 518| 2.32k|} igraph_free: 62| 1.50k|void igraph_free(void *ptr) { 63| | IGRAPH_FREE(ptr); ------------------ | | 36| 1.50k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 64| 1.50k|} igraph_strvector_init: 71| 15.5k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_int_t size) { 72| | 73| 15.5k| sv->stor_begin = IGRAPH_CALLOC(size, const char *); ------------------ | | 33| 15.5k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 31.0k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 15.5k, False: 0] | | | | | Branch (31:24): [True: 15.5k, False: 0] | | | | | Branch (31:66): [True: 8.21k, False: 7.30k] | | | | ------------------ | | ------------------ ------------------ 74| 15.5k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector."); ------------------ | | 709| 15.5k| do { \ | | 710| 15.5k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 15.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 15.5k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 15.5k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 15.5k] | | ------------------ ------------------ 75| | 76| 15.5k| sv->stor_end = sv->stor_begin + size; 77| 15.5k| sv->end = sv->stor_end; 78| | 79| 15.5k| return IGRAPH_SUCCESS; 80| 15.5k|} igraph_strvector_destroy: 95| 15.5k|void igraph_strvector_destroy(igraph_strvector_t *sv) { 96| 15.5k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 15.5k| do { \ | | 925| 15.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 15.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 15.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 15.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 15.5k] | | ------------------ ------------------ 97| 15.5k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 15.5k| do { \ | | 925| 15.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 15.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 15.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 15.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 15.5k] | | ------------------ ------------------ 98| 2.21M| for (const char **ptr = sv->stor_begin; ptr < sv->end; ptr++) { ------------------ | Branch (98:45): [True: 2.20M, False: 15.5k] ------------------ 99| 2.20M| IGRAPH_FREE(*ptr); ------------------ | | 36| 2.20M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 100| 2.20M| } 101| | IGRAPH_FREE(sv->stor_begin); ------------------ | | 36| 15.5k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 102| 15.5k|} igraph_strvector_get: 117| 9.09M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_int_t idx) { 118| 9.09M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 9.09M| do { \ | | 925| 9.09M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 9.09M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 9.09M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 9.09M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 9.09M] | | ------------------ ------------------ 119| 9.09M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 9.09M| do { \ | | 925| 9.09M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 9.09M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 9.09M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 9.09M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 9.09M] | | ------------------ ------------------ 120| 9.09M| return sv->stor_begin[idx] ? sv->stor_begin[idx] : ""; ------------------ | Branch (120:12): [True: 9.09M, False: 0] ------------------ 121| 9.09M|} igraph_strvector_set: 141| 18.8k| const char *value) { 142| 18.8k| return igraph_strvector_set_len(sv, idx, value, strlen(value)); 143| 18.8k|} igraph_strvector_set_len: 163| 18.8k| const char *value, size_t len) { 164| 18.8k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 18.8k| do { \ | | 925| 18.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 18.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 18.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 18.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 18.8k] | | ------------------ ------------------ 165| 18.8k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 18.8k| do { \ | | 925| 18.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 18.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 18.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 18.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 18.8k] | | ------------------ ------------------ 166| | 167| 18.8k| if (sv->stor_begin[idx] == NULL) { ------------------ | Branch (167:9): [True: 11.9k, False: 6.88k] ------------------ 168| 11.9k| sv->stor_begin[idx] = strndup(value, len); 169| 11.9k| IGRAPH_CHECK_OOM(sv->stor_begin[idx], "Cannot reserve space for new item in string vector."); ------------------ | | 709| 11.9k| do { \ | | 710| 11.9k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 11.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.9k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 11.9k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 11.9k] | | ------------------ ------------------ 170| 11.9k| } else { 171| 6.88k| char *tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char); ------------------ | | 35| 6.88k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 13.7k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 6.88k, False: 0] | | | | | Branch (31:24): [True: 6.88k, False: 0] | | | | | Branch (31:66): [True: 6.88k, False: 0] | | | | ------------------ | | ------------------ ------------------ 172| 6.88k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector."); ------------------ | | 709| 6.88k| do { \ | | 710| 6.88k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 6.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 6.88k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 6.88k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 6.88k] | | ------------------ ------------------ 173| | 174| 6.88k| memcpy(tmp, value, len * sizeof(char)); 175| 6.88k| tmp[len] = '\0'; 176| 6.88k| sv->stor_begin[idx] = tmp; 177| 6.88k| } 178| | 179| 18.8k| return IGRAPH_SUCCESS; 180| 18.8k|} igraph_strvector_append: 300| 207| const igraph_strvector_t *from) { 301| 207| const igraph_int_t to_size = igraph_strvector_size(to); 302| 207| const igraph_int_t from_size = igraph_strvector_size(from); 303| 207| const igraph_int_t to_capacity = igraph_strvector_capacity(to); 304| 207| igraph_int_t new_to_size; 305| 207| igraph_bool_t error = false; 306| 207| const char *tmp; 307| | 308| 207| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 207| do { \ | | 48| 207| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 207| igraph_int_t _safe_sum; \ | | 50| 207| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 207] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 464| 0| do { \ | | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 467| 0| return igraph_errno; \ | | | | 468| 0| } while (0) | | | | ------------------ | | | | | Branch (468:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 207| *(res) = _safe_sum; \ | | 54| 207| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 207] | | ------------------ ------------------ 309| | 310| 207| if (to_capacity < new_to_size) { ------------------ | Branch (310:9): [True: 207, False: 0] ------------------ 311| 207| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 207|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 207|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (311:40): [True: 207, False: 0] ------------------ 312| 207| if (new_to_capacity < new_to_size) { ------------------ | Branch (312:13): [True: 207, False: 0] ------------------ 313| 207| new_to_capacity = new_to_size; 314| 207| } 315| 207| IGRAPH_CHECK(igraph_strvector_reserve(to, new_to_capacity)); ------------------ | | 656| 207| do { \ | | 657| 207| igraph_error_t igraph_i_ret = (expr); \ | | 658| 207| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 207| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 207] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 207| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 207] | | ------------------ ------------------ 316| 207| } 317| | 318| 1.06M| for (igraph_int_t i = 0; i < from_size; i++) { ------------------ | Branch (318:30): [True: 1.06M, False: 207] ------------------ 319| 1.06M| if (from->stor_begin[i] == NULL || from->stor_begin[i][0] == '\0') { ------------------ | Branch (319:13): [True: 0, False: 1.06M] | Branch (319:44): [True: 0, False: 1.06M] ------------------ 320| | /* Represent empty strings as NULL. */ 321| 0| tmp = NULL; 322| 1.06M| } else { 323| 1.06M| tmp = strdup(from->stor_begin[i]); 324| 1.06M| if (tmp == NULL) { ------------------ | Branch (324:17): [True: 0, False: 1.06M] ------------------ 325| 0| error = true; 326| 0| break; 327| 0| } 328| 1.06M| } 329| 1.06M| *(to->end) = tmp; 330| 1.06M| to->end++; 331| 1.06M| } 332| | 333| 207| if (error) { ------------------ | Branch (333:9): [True: 0, False: 207] ------------------ 334| 0| igraph_strvector_resize(to, to_size); /* always shrinks */ 335| 0| IGRAPH_ERROR("Cannot append string vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 336| 0| } 337| | 338| 207| return IGRAPH_SUCCESS; 339| 207|} igraph_strvector_clear: 393| 325|void igraph_strvector_clear(igraph_strvector_t *sv) { 394| 325| igraph_int_t n = igraph_strvector_size(sv); 395| | 396| 541k| for (igraph_int_t i = 0; i < n; i++) { ------------------ | Branch (396:30): [True: 541k, False: 325] ------------------ 397| | IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 36| 541k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 398| 541k| } 399| 325| sv->end = sv->stor_begin; 400| 325|} igraph_strvector_resize: 419| 529k|igraph_error_t igraph_strvector_resize(igraph_strvector_t *sv, igraph_int_t newsize) { 420| 529k| igraph_int_t toadd = newsize - igraph_strvector_size(sv); 421| 529k| igraph_int_t oldsize = igraph_strvector_size(sv); 422| | 423| 529k| if (newsize < oldsize) { ------------------ | Branch (423:9): [True: 529k, False: 137] ------------------ 424| 1.05M| for (igraph_int_t i = newsize; i < oldsize; i++) { ------------------ | Branch (424:40): [True: 529k, False: 529k] ------------------ 425| 529k| IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 36| 529k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 426| 529k| } 427| 529k| sv->end = sv->stor_begin + newsize; 428| 529k| } else if (newsize > oldsize) { ------------------ | Branch (428:16): [True: 0, False: 137] ------------------ 429| 0| IGRAPH_CHECK(igraph_strvector_reserve(sv, newsize)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 430| 0| memset(sv->stor_begin + oldsize, 0, toadd * sizeof(const char *)); 431| 0| sv->end = sv->stor_begin + newsize; 432| 0| } 433| | 434| 529k| return IGRAPH_SUCCESS; 435| 529k|} igraph_strvector_capacity: 448| 8.30k|igraph_int_t igraph_strvector_capacity(const igraph_strvector_t *sv) { 449| 8.30k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 8.30k| do { \ | | 925| 8.30k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 8.30k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.30k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.30k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.30k] | | ------------------ ------------------ 450| 8.30k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 8.30k| do { \ | | 925| 8.30k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 8.30k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.30k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.30k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.30k] | | ------------------ ------------------ 451| 8.30k| return sv->stor_end - sv->stor_begin; 452| 8.30k|} igraph_strvector_reserve: 481| 8.09k|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_int_t capacity) { 482| 8.09k| igraph_int_t current_capacity = igraph_strvector_capacity(sv); 483| | 484| 8.09k| if (capacity <= current_capacity) { ------------------ | Branch (484:9): [True: 0, False: 8.09k] ------------------ 485| 0| return IGRAPH_SUCCESS; 486| 0| } 487| | 488| 8.09k| const char **tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, const char *); ------------------ | | 35| 8.09k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 16.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 8.09k, False: 0] | | | | | Branch (31:24): [True: 8.09k, False: 0] | | | | | Branch (31:66): [True: 8.09k, False: 0] | | | | ------------------ | | ------------------ ------------------ 489| 8.09k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector."); ------------------ | | 709| 8.09k| do { \ | | 710| 8.09k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 8.09k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.09k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 8.09k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 8.09k] | | ------------------ ------------------ 490| | 491| 8.09k| sv->end = tmp + (sv->end - sv->stor_begin); 492| 8.09k| sv->stor_begin = tmp; 493| 8.09k| sv->stor_end = sv->stor_begin + capacity; 494| | 495| 8.09k| return IGRAPH_SUCCESS; 496| 8.09k|} igraph_strvector_size: 538| 2.13M|igraph_int_t igraph_strvector_size(const igraph_strvector_t *sv) { 539| 2.13M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 2.13M| do { \ | | 925| 2.13M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.13M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.13M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.13M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.13M] | | ------------------ ------------------ 540| 2.13M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 2.13M| do { \ | | 925| 2.13M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.13M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.13M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.13M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.13M] | | ------------------ ------------------ 541| 2.13M| return sv->end - sv->stor_begin; 542| 2.13M|} igraph_strvector_push_back: 580| 560k|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) { 581| 560k| IGRAPH_CHECK(strvector_expand_if_full(sv)); ------------------ | | 656| 560k| do { \ | | 657| 560k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 560k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 560k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 560k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 560k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 560k] | | ------------------ ------------------ 582| 560k| const char *tmp = strdup(value); 583| 560k| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector."); ------------------ | | 709| 560k| do { \ | | 710| 560k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 560k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 560k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 560k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 560k] | | ------------------ ------------------ 584| 560k| *sv->end = tmp; 585| 560k| sv->end++; 586| | 587| 560k| return IGRAPH_SUCCESS; 588| 560k|} igraph_strvector_push_back_len: 606| 1.63M| const char *value, size_t len) { 607| | 608| 1.63M| IGRAPH_CHECK(strvector_expand_if_full(sv)); ------------------ | | 656| 1.63M| do { \ | | 657| 1.63M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.63M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.63M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.63M] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 1.63M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.63M] | | ------------------ ------------------ 609| 1.63M| const char *tmp = strndup(value, len); 610| 1.63M| IGRAPH_CHECK_OOM(tmp, "Insufficient memory to push to string vector."); ------------------ | | 709| 1.63M| do { \ | | 710| 1.63M| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.63M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.63M] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 1.63M| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.63M] | | ------------------ ------------------ 611| 1.63M| *sv->end = tmp; 612| 1.63M| sv->end++; 613| | 614| 1.63M| return IGRAPH_SUCCESS; 615| 1.63M|} igraph_strvector_update: 698| 172|) { 699| 172| igraph_strvector_clear(to); 700| 172| IGRAPH_CHECK(igraph_strvector_append(to, from)); ------------------ | | 656| 172| do { \ | | 657| 172| igraph_error_t igraph_i_ret = (expr); \ | | 658| 172| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 172| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 172] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 172| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 172] | | ------------------ ------------------ 701| 172| return IGRAPH_SUCCESS; 702| 172|} strvector.c:strvector_expand_if_full: 548| 2.19M|static igraph_error_t strvector_expand_if_full(igraph_strvector_t *sv) { 549| 2.19M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 2.19M| do { \ | | 925| 2.19M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.19M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.19M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.19M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.19M] | | ------------------ ------------------ 550| 2.19M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 2.19M| do { \ | | 925| 2.19M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.19M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.19M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.19M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.19M] | | ------------------ ------------------ 551| | 552| 2.19M| if (sv->stor_end == sv->end) { ------------------ | Branch (552:9): [True: 7.88k, False: 2.18M] ------------------ 553| 7.88k| igraph_int_t old_size = igraph_strvector_size(sv); 554| 7.88k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.88k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.88k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (554:33): [True: 7.88k, False: 0] ------------------ 555| 7.88k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 7.88k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (555:13): [True: 0, False: 7.88k] ------------------ 556| 0| IGRAPH_ERROR("Cannot add new item to string vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 557| 0| } 558| 7.88k| if (new_size == 0) { ------------------ | Branch (558:13): [True: 1.03k, False: 6.85k] ------------------ 559| 1.03k| new_size = 1; 560| 1.03k| } 561| 7.88k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size)); ------------------ | | 656| 7.88k| do { \ | | 657| 7.88k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 7.88k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 7.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.88k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 7.88k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 7.88k] | | ------------------ ------------------ 562| 7.88k| } 563| | 564| 2.19M| return IGRAPH_SUCCESS; 565| 2.19M|} igraph_trie_init: 61| 2.32k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) { 62| 2.32k| t->maxvalue = -1; 63| 2.32k| t->storekeys = storekeys; 64| 2.32k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node)); ------------------ | | 656| 2.32k| do { \ | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 2.32k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.32k] | | ------------------ ------------------ 65| 2.32k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node); ------------------ | | 603| 2.32k| do { \ | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | 607| 2.32k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.32k] | | ------------------ | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.32k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.32k] | | ------------------ ------------------ 66| 2.32k| if (storekeys) { ------------------ | Branch (66:9): [True: 2.32k, False: 0] ------------------ 67| 2.32k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0)); ------------------ | | 656| 2.32k| do { \ | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 2.32k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.32k] | | ------------------ ------------------ 68| 2.32k| } 69| | 70| 2.32k| IGRAPH_FINALLY_CLEAN(1); 71| 2.32k| return IGRAPH_SUCCESS; 72| 2.32k|} igraph_trie_destroy: 102| 2.32k|void igraph_trie_destroy(igraph_trie_t *t) { 103| 2.32k| if (t->storekeys) { ------------------ | Branch (103:9): [True: 2.32k, False: 0] ------------------ 104| 2.32k| igraph_strvector_destroy(&t->keys); 105| 2.32k| } 106| 2.32k| igraph_i_trie_destroy_node(&t->node); 107| 2.32k|} igraph_trie_get: 298| 549k|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_int_t *id) { 299| 549k| assert(key != NULL); ------------------ | Branch (299:5): [True: 0, False: 549k] | Branch (299:5): [True: 549k, False: 0] ------------------ 300| | 301| 549k| if (*key == '\0') { ------------------ | Branch (301:9): [True: 0, False: 549k] ------------------ 302| 0| IGRAPH_ERROR("Keys in a trie cannot be empty.", IGRAPH_EINVAL); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 303| 0| } 304| | 305| 549k| if (!t->storekeys) { ------------------ | Branch (305:9): [True: 0, False: 549k] ------------------ 306| 0| IGRAPH_CHECK(igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 307| 0| if (*id > t->maxvalue) { ------------------ | Branch (307:13): [True: 0, False: 0] ------------------ 308| 0| t->maxvalue = *id; 309| 0| } 310| 549k| } else { 311| 549k| igraph_error_t ret; 312| | 313| 549k| IGRAPH_FINALLY_ENTER(); 314| | /* Add it to the string vector first, we can undo this later */ 315| 549k| ret = igraph_strvector_push_back(&t->keys, key); 316| 549k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (316:13): [True: 0, False: 549k] ------------------ 317| 0| IGRAPH_FINALLY_EXIT(); 318| 0| IGRAPH_ERROR("Cannot get element from trie.", ret); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 319| 0| } 320| 549k| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id); 321| 549k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (321:13): [True: 0, False: 549k] ------------------ 322| 0| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */ 323| 0| IGRAPH_FINALLY_EXIT(); 324| 0| IGRAPH_ERROR("Cannot get element from trie.", ret); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 325| 0| } 326| | 327| | /* everything is fine */ 328| 549k| if (*id > t->maxvalue) { ------------------ | Branch (328:13): [True: 20.2k, False: 529k] ------------------ 329| 20.2k| t->maxvalue = *id; 330| 529k| } else { 331| 529k| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */ 332| 529k| } 333| 549k| IGRAPH_FINALLY_EXIT(); 334| 549k| } 335| | 336| 549k| return IGRAPH_SUCCESS; 337| 549k|} igraph_trie_get_len: 357| 8.51k| igraph_int_t *id) { 358| | 359| 8.51k| char *tmp = strndup(key, length); 360| 8.51k| IGRAPH_CHECK_OOM(tmp, "Cannot get from trie."); ------------------ | | 709| 8.51k| do { \ | | 710| 8.51k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 8.51k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.51k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 8.51k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 8.51k] | | ------------------ ------------------ 361| 8.51k| IGRAPH_FINALLY(igraph_free, tmp); ------------------ | | 603| 8.51k| do { \ | | 604| 8.51k| /* the following branch makes the compiler check the compatibility of \ | | 605| 8.51k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 8.51k| * incorrect destructor function with the pointer */ \ | | 607| 8.51k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 8.51k] | | ------------------ | | 608| 8.51k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 8.51k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 8.51k] | | ------------------ ------------------ 362| 8.51k| IGRAPH_CHECK(igraph_trie_get(t, tmp, id)); ------------------ | | 656| 8.51k| do { \ | | 657| 8.51k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 8.51k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 8.51k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.51k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 8.51k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 8.51k] | | ------------------ ------------------ 363| 8.51k| IGRAPH_FREE(tmp); ------------------ | | 36| 8.51k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 364| 8.51k| IGRAPH_FINALLY_CLEAN(1); 365| | 366| 8.51k| return IGRAPH_SUCCESS; 367| 8.51k|} igraph_trie_size: 413| 731|igraph_int_t igraph_trie_size(igraph_trie_t *t) { 414| 731| return t->maxvalue + 1; 415| 731|} igraph_i_trie_borrow_keys: 432| 76|const igraph_strvector_t* igraph_i_trie_borrow_keys(igraph_trie_t *t) { 433| 76| return &t->keys; 434| 76|} trie.c:igraph_i_trie_init_node: 41| 2.32k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) { 42| 2.32k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0); ------------------ | | 62| 2.32k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 2.32k| do { \ | | | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | 63| 2.32k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 2.32k| do { \ | | | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.32k] | | | | ------------------ | | | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 2.32k] | | ------------------ ------------------ 43| 2.32k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0); ------------------ | | 46| 2.32k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 2.32k| do { \ | | | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | 47| 2.32k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 2.32k| do { \ | | | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.32k] | | | | ------------------ | | | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 2.32k] | | ------------------ ------------------ 44| 2.32k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0); ------------------ | | 119| 2.32k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 2.32k| do { \ | | | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | 120| 2.32k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 2.32k| do { \ | | | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.32k] | | | | ------------------ | | | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 2.32k] | | ------------------ ------------------ 45| 2.32k| IGRAPH_FINALLY_CLEAN(3); 46| 2.32k| return IGRAPH_SUCCESS; 47| 2.32k|} trie.c:igraph_i_trie_destroy_node: 91| 2.32k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) { 92| | igraph_i_trie_destroy_node_helper(t, false); 93| 2.32k|} trie.c:igraph_i_trie_destroy_node_helper: 74| 10.5k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) { 75| 10.5k| igraph_strvector_destroy(&t->strs); 76| 10.5k| igraph_int_t children_size = igraph_vector_ptr_size(&t->children); 77| 33.7k| for (igraph_int_t i = 0; i < children_size; i++) { ------------------ | Branch (77:30): [True: 23.2k, False: 10.5k] ------------------ 78| 23.2k| igraph_trie_node_t *child = VECTOR(t->children)[i]; ------------------ | | 60| 23.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 79| 23.2k| if (child != NULL) { ------------------ | Branch (79:13): [True: 8.21k, False: 15.0k] ------------------ 80| 8.21k| igraph_i_trie_destroy_node_helper(child, true); 81| 8.21k| } 82| 23.2k| } 83| 10.5k| igraph_vector_ptr_destroy(&t->children); 84| 10.5k| igraph_vector_int_destroy(&t->values); 85| 10.5k| if (sfree) { ------------------ | Branch (85:9): [True: 8.21k, False: 2.32k] ------------------ 86| | IGRAPH_FREE(t); ------------------ | | 36| 8.21k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 87| 8.21k| } 88| 10.5k|} trie.c:igraph_i_trie_get_node: 129| 1.05M|) { 130| 1.05M| assert(key != NULL); ------------------ | Branch (130:5): [True: 0, False: 1.05M] | Branch (130:5): [True: 1.05M, False: 0] ------------------ 131| | 132| | /* If newvalue is negative, we don't add the node if nonexistent, only check 133| | * for its existence */ 134| 1.05M| igraph_bool_t add = (newvalue >= 0); 135| | 136| 1.05M| igraph_int_t strs_size = igraph_strvector_size(&t->strs); 137| 8.56M| for (igraph_int_t i = 0; i < strs_size; i++) { ------------------ | Branch (137:30): [True: 8.55M, False: 11.3k] ------------------ 138| 8.55M| size_t diff; 139| 8.55M| const char *str = igraph_strvector_get(&t->strs, i); 140| 8.55M| diff = igraph_i_strdiff(str, key); 141| | 142| 8.55M| if (diff == 0) { ------------------ | Branch (142:13): [True: 7.50M, False: 1.04M] ------------------ 143| | 144| | /* ------------------------------------ */ 145| | /* No match, next */ 146| | 147| 7.50M| } else if (str[diff] == '\0' && key[diff] == '\0') { ------------------ | Branch (147:20): [True: 1.03M, False: 6.88k] | Branch (147:41): [True: 530k, False: 509k] ------------------ 148| | 149| | /* ------------------------------------ */ 150| | /* They are exactly the same */ 151| 530k| if (VECTOR(t->values)[i] != -1) { ------------------ | | 60| 530k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (151:17): [True: 529k, False: 685] ------------------ 152| 529k| *id = VECTOR(t->values)[i]; ------------------ | | 60| 529k|#define VECTOR(v) ((v).stor_begin) ------------------ 153| 529k| return IGRAPH_SUCCESS; 154| 529k| } else { 155| 685| VECTOR(t->values)[i] = newvalue; ------------------ | | 60| 685|#define VECTOR(v) ((v).stor_begin) ------------------ 156| 685| *id = newvalue; 157| 685| return IGRAPH_SUCCESS; 158| 685| } 159| | 160| 530k| } else if (str[diff] == '\0') { ------------------ | Branch (160:20): [True: 509k, False: 6.88k] ------------------ 161| | 162| | /* ------------------------------------ */ 163| | /* str is prefix of key, follow its link if there is one */ 164| 509k| igraph_trie_node_t *node = VECTOR(t->children)[i]; ------------------ | | 60| 509k|#define VECTOR(v) ((v).stor_begin) ------------------ 165| 509k| if (node != NULL) { ------------------ | Branch (165:17): [True: 508k, False: 1.32k] ------------------ 166| 508k| return igraph_i_trie_get_node(node, key + diff, newvalue, id); 167| 508k| } else if (add) { ------------------ | Branch (167:24): [True: 1.32k, False: 0] ------------------ 168| 1.32k| igraph_trie_node_t *new_node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 1.32k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 2.65k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 1.32k, Folded] | | | | ------------------ | | ------------------ ------------------ 169| 1.32k| IGRAPH_CHECK_OOM(new_node, "Cannot add to trie."); ------------------ | | 709| 1.32k| do { \ | | 710| 1.32k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.32k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 1.32k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.32k] | | ------------------ ------------------ 170| 1.32k| IGRAPH_FINALLY(igraph_free, new_node); ------------------ | | 603| 1.32k| do { \ | | 604| 1.32k| /* the following branch makes the compiler check the compatibility of \ | | 605| 1.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 1.32k| * incorrect destructor function with the pointer */ \ | | 607| 1.32k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 1.32k] | | ------------------ | | 608| 1.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 1.32k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 1.32k] | | ------------------ ------------------ 171| | 172| 1.32k| IGRAPH_STRVECTOR_INIT_FINALLY(&new_node->strs, 1); ------------------ | | 62| 1.32k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 1.32k| do { \ | | | | 657| 1.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 1.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.32k] | | | | ------------------ | | ------------------ | | 63| 1.32k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 1.32k| do { \ | | | | 604| 1.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.32k] | | | | ------------------ | | | | 608| 1.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.32k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 1.32k] | | ------------------ ------------------ 173| 1.32k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&new_node->children, 1); ------------------ | | 46| 1.32k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 1.32k| do { \ | | | | 657| 1.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 1.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.32k] | | | | ------------------ | | ------------------ | | 47| 1.32k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 1.32k| do { \ | | | | 604| 1.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.32k] | | | | ------------------ | | | | 608| 1.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.32k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 1.32k] | | ------------------ ------------------ 174| 1.32k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_node->values, 1); ------------------ | | 119| 1.32k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 1.32k| do { \ | | | | 657| 1.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 1.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.32k] | | | | ------------------ | | ------------------ | | 120| 1.32k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 1.32k| do { \ | | | | 604| 1.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.32k] | | | | ------------------ | | | | 608| 1.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.32k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 1.32k] | | ------------------ ------------------ 175| 1.32k| IGRAPH_CHECK(igraph_strvector_set(&new_node->strs, 0, key + diff)); ------------------ | | 656| 1.32k| do { \ | | 657| 1.32k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.32k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 1.32k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.32k] | | ------------------ ------------------ 176| 1.32k| IGRAPH_FINALLY_CLEAN(4); 177| | 178| 1.32k| VECTOR(new_node->children)[0] = 0; ------------------ | | 60| 1.32k|#define VECTOR(v) ((v).stor_begin) ------------------ 179| 1.32k| VECTOR(new_node->values)[0] = newvalue; ------------------ | | 60| 1.32k|#define VECTOR(v) ((v).stor_begin) ------------------ 180| | 181| 1.32k| VECTOR(t->children)[i] = new_node; ------------------ | | 60| 1.32k|#define VECTOR(v) ((v).stor_begin) ------------------ 182| | 183| 1.32k| *id = newvalue; 184| 1.32k| return IGRAPH_SUCCESS; 185| 1.32k| } else { 186| 0| *id = -1; 187| 0| return IGRAPH_SUCCESS; 188| 0| } 189| | 190| 509k| } else if (key[diff] == '\0' && add) { ------------------ | Branch (190:20): [True: 3.16k, False: 3.71k] | Branch (190:41): [True: 3.16k, False: 0] ------------------ 191| | 192| | /* ------------------------------------ */ 193| | /* key is prefix of str, the node has to be cut */ 194| 3.16k| char *str2; 195| | 196| 3.16k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 3.16k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 6.33k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 3.16k, Folded] | | | | ------------------ | | ------------------ ------------------ 197| 3.16k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 709| 3.16k| do { \ | | 710| 3.16k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 3.16k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.16k] | | ------------------ ------------------ 198| 3.16k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 603| 3.16k| do { \ | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | 607| 3.16k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.16k] | | ------------------ | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.16k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.16k] | | ------------------ ------------------ 199| | 200| 3.16k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1); ------------------ | | 62| 3.16k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 3.16k| do { \ | | | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | 63| 3.16k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 3.16k| do { \ | | | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.16k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.16k] | | | | ------------------ | | | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 3.16k] | | ------------------ ------------------ 201| 3.16k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1); ------------------ | | 46| 3.16k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 3.16k| do { \ | | | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | 47| 3.16k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 3.16k| do { \ | | | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.16k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.16k] | | | | ------------------ | | | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 3.16k] | | ------------------ ------------------ 202| 3.16k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1); ------------------ | | 119| 3.16k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 3.16k| do { \ | | | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | 120| 3.16k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 3.16k| do { \ | | | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.16k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.16k] | | | | ------------------ | | | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 3.16k] | | ------------------ ------------------ 203| 3.16k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 656| 3.16k| do { \ | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.16k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.16k] | | ------------------ ------------------ 204| | 205| 3.16k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 206| 3.16k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 207| | 208| 3.16k| str2 = strdup(str); 209| 3.16k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 709| 3.16k| do { \ | | 710| 3.16k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 3.16k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.16k] | | ------------------ ------------------ 210| 3.16k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 603| 3.16k| do { \ | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | 607| 3.16k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.16k] | | ------------------ | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.16k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.16k] | | ------------------ ------------------ 211| 3.16k| str2[diff] = '\0'; 212| | 213| 3.16k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 656| 3.16k| do { \ | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.16k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.16k] | | ------------------ ------------------ 214| | 215| 3.16k| IGRAPH_FREE(str2); ------------------ | | 36| 3.16k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 216| 3.16k| IGRAPH_FINALLY_CLEAN(5); 217| | 218| 3.16k| VECTOR(t->values)[i] = newvalue; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 219| 3.16k| VECTOR(t->children)[i] = node; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 220| | 221| 3.16k| *id = newvalue; 222| 3.16k| return IGRAPH_SUCCESS; 223| | 224| 3.71k| } else if (add) { ------------------ | Branch (224:20): [True: 3.71k, False: 0] ------------------ 225| | 226| | /* ------------------------------------ */ 227| | /* the first diff characters match */ 228| 3.71k| char *str2; 229| | 230| 3.71k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 3.71k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 7.43k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 3.71k, Folded] | | | | ------------------ | | ------------------ ------------------ 231| 3.71k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 709| 3.71k| do { \ | | 710| 3.71k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 3.71k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.71k] | | ------------------ ------------------ 232| 3.71k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 603| 3.71k| do { \ | | 604| 3.71k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.71k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.71k| * incorrect destructor function with the pointer */ \ | | 607| 3.71k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.71k] | | ------------------ | | 608| 3.71k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.71k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.71k] | | ------------------ ------------------ 233| | 234| 3.71k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2); ------------------ | | 62| 3.71k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 3.71k| do { \ | | | | 657| 3.71k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.71k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.71k] | | | | ------------------ | | ------------------ | | 63| 3.71k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 3.71k| do { \ | | | | 604| 3.71k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.71k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.71k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.71k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.71k] | | | | ------------------ | | | | 608| 3.71k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.71k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.71k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 3.71k] | | ------------------ ------------------ 235| 3.71k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2); ------------------ | | 46| 3.71k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 3.71k| do { \ | | | | 657| 3.71k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.71k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.71k] | | | | ------------------ | | ------------------ | | 47| 3.71k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 3.71k| do { \ | | | | 604| 3.71k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.71k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.71k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.71k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.71k] | | | | ------------------ | | | | 608| 3.71k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.71k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.71k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 3.71k] | | ------------------ ------------------ 236| 3.71k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2); ------------------ | | 119| 3.71k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 3.71k| do { \ | | | | 657| 3.71k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.71k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.71k] | | | | ------------------ | | ------------------ | | 120| 3.71k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 3.71k| do { \ | | | | 604| 3.71k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.71k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.71k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.71k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.71k] | | | | ------------------ | | | | 608| 3.71k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.71k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.71k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 3.71k] | | ------------------ ------------------ 237| 3.71k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 656| 3.71k| do { \ | | 657| 3.71k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.71k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.71k] | | ------------------ ------------------ 238| 3.71k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff)); ------------------ | | 656| 3.71k| do { \ | | 657| 3.71k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.71k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.71k] | | ------------------ ------------------ 239| 3.71k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ 240| 3.71k| VECTOR(node->children)[1] = 0; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ 241| 3.71k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ 242| 3.71k| VECTOR(node->values)[1] = newvalue; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ 243| | 244| 3.71k| str2 = strdup(str); 245| 3.71k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 709| 3.71k| do { \ | | 710| 3.71k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 3.71k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.71k] | | ------------------ ------------------ 246| | 247| 3.71k| str2[diff] = '\0'; 248| 3.71k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 603| 3.71k| do { \ | | 604| 3.71k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.71k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.71k| * incorrect destructor function with the pointer */ \ | | 607| 3.71k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.71k] | | ------------------ | | 608| 3.71k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.71k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.71k] | | ------------------ ------------------ 249| | 250| 3.71k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 656| 3.71k| do { \ | | 657| 3.71k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.71k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.71k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.71k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.71k] | | ------------------ ------------------ 251| | 252| 3.71k| IGRAPH_FREE(str2); ------------------ | | 36| 3.71k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 253| 3.71k| IGRAPH_FINALLY_CLEAN(5); 254| | 255| 3.71k| VECTOR(t->values)[i] = -1; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ 256| 3.71k| VECTOR(t->children)[i] = node; ------------------ | | 60| 3.71k|#define VECTOR(v) ((v).stor_begin) ------------------ 257| | 258| 3.71k| *id = newvalue; 259| 3.71k| return IGRAPH_SUCCESS; 260| 3.71k| } else { 261| | 262| | /* ------------------------------------------------- */ 263| | /* No match, but we requested not to add the new key */ 264| 0| *id = -1; 265| 0| return IGRAPH_SUCCESS; 266| 0| } 267| 8.55M| } 268| | 269| | /* ------------------------------------ */ 270| | /* Nothing matches */ 271| | 272| 11.3k| if (add) { ------------------ | Branch (272:9): [True: 11.3k, False: 0] ------------------ 273| | /* Memory saving at the cost of performance may be possible by using the pattern 274| | * CHECK(reserve(vec, size(vec) + 1)); 275| | * push_back(vec, value); 276| | * This was the original pattern used before igraph 0.10. */ 277| 11.3k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key)); ------------------ | | 656| 11.3k| do { \ | | 657| 11.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 11.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 11.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 11.3k] | | ------------------ ------------------ 278| 11.3k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL)); ------------------ | | 656| 11.3k| do { \ | | 657| 11.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 11.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 11.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 11.3k] | | ------------------ ------------------ 279| 11.3k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue)); ------------------ | | 656| 11.3k| do { \ | | 657| 11.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 11.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 11.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 11.3k] | | ------------------ ------------------ 280| 11.3k| *id = newvalue; 281| 11.3k| } else { 282| 0| *id = -1; 283| 0| } 284| | 285| 11.3k| return IGRAPH_SUCCESS; 286| 11.3k|} trie.c:igraph_i_strdiff: 111| 8.55M|static size_t igraph_i_strdiff(const char *str, const char *key) { 112| 8.55M| size_t diff = 0; 113| 9.98M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) { ------------------ | Branch (113:12): [True: 9.45M, False: 533k] | Branch (113:33): [True: 8.94M, False: 509k] | Branch (113:54): [True: 1.43M, False: 7.51M] ------------------ 114| 1.43M| diff++; 115| 1.43M| } 116| 8.55M| return diff; 117| 8.55M|} igraph_attribute_record_list_init: 109| 2.91k|igraph_error_t FUNCTION(init)(TYPE *v, igraph_int_t size) { 110| 2.91k| igraph_int_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (110:31): [True: 434, False: 2.48k] ------------------ 111| 2.91k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 2.91k| do { \ | | 925| 2.91k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.91k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.91k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.91k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.91k] | | ------------------ ------------------ 112| 2.91k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE); ------------------ | | 33| 2.91k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 5.83k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 2.91k, False: 0] | | | | | Branch (31:24): [True: 2.91k, False: 0] | | | | | Branch (31:66): [True: 2.91k, False: 0] | | | | ------------------ | | ------------------ ------------------ 113| 2.91k| if (v->stor_begin == 0) { ------------------ | Branch (113:9): [True: 0, False: 2.91k] ------------------ 114| 0| IGRAPH_ERROR("Cannot initialize list.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 115| 0| } 116| 2.91k| v->stor_end = v->stor_begin + alloc_size; 117| 2.91k| v->end = v->stor_begin + size; 118| | 119| 2.91k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end)); ------------------ | | 656| 2.91k| do { \ | | 657| 2.91k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.91k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.91k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.91k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 2.91k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.91k] | | ------------------ ------------------ 120| | 121| 2.91k| return IGRAPH_SUCCESS; 122| 2.91k|} igraph_attribute_record_list_destroy: 176| 2.91k|void FUNCTION(destroy)(TYPE *v) { 177| 2.91k| IGRAPH_ASSERT(v != 0); ------------------ | | 924| 2.91k| do { \ | | 925| 2.91k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.91k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.91k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.91k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.91k] | | ------------------ ------------------ 178| | 179| 2.91k| if (v->stor_begin != 0) { ------------------ | Branch (179:9): [True: 2.91k, False: 0] ------------------ 180| 2.91k| FUNCTION(clear)(v); ------------------ | | 161| 2.91k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c) | | ------------------ | | | | 19| 2.91k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 181| 2.91k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 2.91k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 182| | v->stor_begin = NULL; 183| 2.91k| } 184| 2.91k|} igraph_attribute_record_list_size: 287| 3.24k|igraph_int_t FUNCTION(size)(const TYPE *v) { 288| 3.24k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 3.24k| do { \ | | 925| 3.24k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.24k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.24k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.24k] | | ------------------ ------------------ 289| 3.24k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 3.24k| do { \ | | 925| 3.24k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.24k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.24k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.24k] | | ------------------ ------------------ 290| 3.24k| return v->end - v->stor_begin; 291| 3.24k|} igraph_attribute_record_list_clear: 357| 2.91k|void FUNCTION(clear)(TYPE *v) { 358| 2.91k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.91k| do { \ | | 925| 2.91k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.91k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.91k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.91k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.91k] | | ------------------ ------------------ 359| 2.91k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 2.91k| do { \ | | 925| 2.91k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.91k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.91k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.91k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.91k] | | ------------------ ------------------ 360| 2.91k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end); ------------------ | | 162| 2.91k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 2.91k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 361| 2.91k| v->end = v->stor_begin; 362| 2.91k|} igraph_attribute_record_list_get_ptr: 377| 1.85k|ITEM_TYPE *FUNCTION(get_ptr)(const TYPE *v, igraph_int_t pos) { 378| 1.85k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 1.85k| do { \ | | 925| 1.85k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.85k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.85k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.85k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.85k] | | ------------------ ------------------ 379| 1.85k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 1.85k| do { \ | | 925| 1.85k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.85k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.85k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.85k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.85k] | | ------------------ ------------------ 380| 1.85k| return v->stor_begin + pos; 381| 1.85k|} igraph_attribute_record_list_push_back_new: 640| 320|igraph_error_t FUNCTION(push_back_new)(TYPE *v, ITEM_TYPE** e) { 641| 320| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v)); ------------------ | | 656| 320| do { \ | | 657| 320| igraph_error_t igraph_i_ret = (expr); \ | | 658| 320| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 320| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 320] | | ------------------ ------------------ 642| 320| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end)); ------------------ | | 656| 320| do { \ | | 657| 320| igraph_error_t igraph_i_ret = (expr); \ | | 658| 320| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 320| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 320] | | ------------------ ------------------ 643| 320| if (e) { ------------------ | Branch (643:9): [True: 320, False: 0] ------------------ 644| 320| *e = v->end; 645| 320| } 646| 320| v->end += 1; 647| 320| return IGRAPH_SUCCESS; 648| 320|} attributes.c:igraph_i_attribute_record_list_init_slice: 1068| 2.91k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1069| 2.91k| ITEM_TYPE *current; ------------------ | | 61| 2.91k| #define ITEM_TYPE BASE | | ------------------ | | | | 115| 2.91k| #define BASE igraph_attribute_record_t | | ------------------ ------------------ 1070| 2.91k| igraph_error_t retval; 1071| | 1072| 3.34k| for (current = start; current < end; current++) { ------------------ | Branch (1072:27): [True: 434, False: 2.91k] ------------------ 1073| 434| retval = INTERNAL_FUNCTION(init_item)(list, current); ------------------ | | 162| 434| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 434|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1074| 434| if (retval) { ------------------ | Branch (1074:13): [True: 0, False: 434] ------------------ 1075| 0| INTERNAL_FUNCTION(destroy_slice)(list, start, current); ------------------ | | 162| 0| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 0|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1076| 0| IGRAPH_CHECK(retval); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 1077| 0| } 1078| 434| } 1079| | 1080| 2.91k| return IGRAPH_SUCCESS; 1081| 2.91k|} attributes.c:igraph_i_attribute_record_list_destroy_slice: 1083| 2.91k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1084| 2.91k| IGRAPH_UNUSED(list); ------------------ | | 30| 2.91k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 1085| 3.66k| for (; start < end; start++) { ------------------ | Branch (1085:12): [True: 754, False: 2.91k] ------------------ 1086| 754| INTERNAL_FUNCTION(destroy_item)(start); ------------------ | | 162| 754| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 754|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1087| 754| } 1088| 2.91k|} attributes.c:igraph_i_attribute_record_list_expand_if_full: 1094| 320|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE *v) { 1095| 320| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 320| do { \ | | 925| 320| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 320| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 320] | | ------------------ ------------------ 1096| 320| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 320| do { \ | | 925| 320| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 320| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 320] | | ------------------ ------------------ 1097| | 1098| 320| if (v->stor_end == v->end) { ------------------ | Branch (1098:9): [True: 0, False: 320] ------------------ 1099| 0| igraph_int_t old_size = FUNCTION(size)(v); ------------------ | | 161| 0| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c) | | ------------------ | | | | 19| 0|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1100| 0| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (1100:33): [True: 0, False: 0] ------------------ 1101| 0| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 0|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (1101:13): [True: 0, False: 0] ------------------ 1102| 0| IGRAPH_ERROR("Cannot add new item to list, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 1103| 0| } 1104| 0| if (new_size == 0) { ------------------ | Branch (1104:13): [True: 0, False: 0] ------------------ 1105| 0| new_size = 1; 1106| 0| } 1107| 0| IGRAPH_CHECK(FUNCTION(reserve)(v, new_size)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 1108| 0| } 1109| | 1110| 320| return IGRAPH_SUCCESS; 1111| 320|} igraph_vector_int_pair_order: 119| 996| igraph_vector_int_t* res, igraph_int_t nodes) { 120| 996| igraph_int_t edges = igraph_vector_int_size(v); 121| 996| igraph_vector_int_t ptr; 122| 996| igraph_vector_int_t rad; 123| 996| igraph_int_t i, j; 124| | 125| 996| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 996| do { \ | | 925| 996| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 996| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 996] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 996| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 996] | | ------------------ ------------------ 126| 996| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 996| do { \ | | 925| 996| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 996| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 996] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 996| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 996] | | ------------------ ------------------ 127| | 128| 996| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1); ------------------ | | 119| 996| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 996| do { \ | | | | 657| 996| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 996| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 996| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 996| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 996] | | | | ------------------ | | ------------------ | | 120| 996| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 996| do { \ | | | | 604| 996| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 996| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 996| * incorrect destructor function with the pointer */ \ | | | | 607| 996| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 996] | | | | ------------------ | | | | 608| 996| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 996| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 996] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 996] | | ------------------ ------------------ 129| 996| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges); ------------------ | | 119| 996| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 996| do { \ | | | | 657| 996| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 996| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 996| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 996| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 996] | | | | ------------------ | | ------------------ | | 120| 996| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 996| do { \ | | | | 604| 996| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 996| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 996| * incorrect destructor function with the pointer */ \ | | | | 607| 996| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 996] | | | | ------------------ | | | | 608| 996| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 996| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 996] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 996] | | ------------------ ------------------ 130| 996| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 656| 996| do { \ | | 657| 996| igraph_error_t igraph_i_ret = (expr); \ | | 658| 996| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 996| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 996] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 996| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 996] | | ------------------ ------------------ 131| | 132| 6.94M| for (i = 0; i < edges; i++) { ------------------ | Branch (132:17): [True: 6.94M, False: 996] ------------------ 133| 6.94M| igraph_int_t radix = VECTOR(*v2)[i]; ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ 134| 6.94M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (134:13): [True: 6.91M, False: 32.5k] ------------------ 135| 6.91M| VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 136| 6.91M| } 137| 6.94M| VECTOR(ptr)[radix] = i + 1; ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ 138| 6.94M| } 139| | 140| 996| j = 0; 141| 82.8M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (141:17): [True: 82.8M, False: 996] ------------------ 142| 82.8M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 60| 82.8M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (142:13): [True: 32.5k, False: 82.8M] ------------------ 143| 32.5k| igraph_int_t next = VECTOR(ptr)[i] - 1; ------------------ | | 60| 32.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 144| 32.5k| VECTOR(*res)[j++] = next; ------------------ | | 60| 32.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 145| 6.94M| while (VECTOR(rad)[next] != 0) { ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (145:20): [True: 6.91M, False: 32.5k] ------------------ 146| 6.91M| next = VECTOR(rad)[next] - 1; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 147| 6.91M| VECTOR(*res)[j++] = next; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 148| 6.91M| } 149| 32.5k| } 150| 82.8M| } 151| | 152| 996| igraph_vector_int_null(&ptr); 153| 996| igraph_vector_int_null(&rad); 154| | 155| 6.94M| for (i = 0; i < edges; i++) { ------------------ | Branch (155:17): [True: 6.94M, False: 996] ------------------ 156| 6.94M| igraph_int_t edge = VECTOR(*res)[edges - i - 1]; ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ 157| 6.94M| igraph_int_t radix = VECTOR(*v)[edge]; ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ 158| 6.94M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (158:13): [True: 6.91M, False: 32.5k] ------------------ 159| 6.91M| VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 160| 6.91M| } 161| 6.94M| VECTOR(ptr)[radix] = edge + 1; ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ 162| 6.94M| } 163| | 164| 996| j = 0; 165| 82.8M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (165:17): [True: 82.8M, False: 996] ------------------ 166| 82.8M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 60| 82.8M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (166:13): [True: 32.5k, False: 82.8M] ------------------ 167| 32.5k| igraph_int_t next = VECTOR(ptr)[i] - 1; ------------------ | | 60| 32.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 168| 32.5k| VECTOR(*res)[j++] = next; ------------------ | | 60| 32.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 169| 6.94M| while (VECTOR(rad)[next] != 0) { ------------------ | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (169:20): [True: 6.91M, False: 32.5k] ------------------ 170| 6.91M| next = VECTOR(rad)[next] - 1; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 171| 6.91M| VECTOR(*res)[j++] = next; ------------------ | | 60| 6.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 172| 6.91M| } 173| 32.5k| } 174| 82.8M| } 175| | 176| 996| igraph_vector_int_destroy(&ptr); 177| 996| igraph_vector_int_destroy(&rad); 178| 996| IGRAPH_FINALLY_CLEAN(2); 179| | 180| 996| return IGRAPH_SUCCESS; 181| 996|} igraph_vector_init: 134| 2.73k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) { 135| 2.73k| igraph_int_t alloc_size; 136| 2.73k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 2.73k| do { \ | | 925| 2.73k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.73k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.73k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.73k] | | ------------------ ------------------ 137| 2.73k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (137:18): [True: 0, False: 2.73k] ------------------ 138| | 139| | /* When this function fails, it should leave stor_begin set to NULL, 140| | * so that vector_destroy() is still safe to call on the vector. 141| | * This simplifies freeing partially initialized data structures, 142| | * such as adjacency lists, when an error occurs mid-initialization. */ 143| 2.73k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 33| 2.73k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 5.46k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 2.73k, False: 0] | | | | | Branch (31:24): [True: 2.73k, False: 0] | | | | | Branch (31:66): [True: 2.73k, False: 0] | | | | ------------------ | | ------------------ ------------------ 144| 2.73k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector."); ------------------ | | 709| 2.73k| do { \ | | 710| 2.73k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 2.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.73k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 2.73k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 2.73k] | | ------------------ ------------------ 145| 2.73k| v->stor_end = v->stor_begin + alloc_size; 146| 2.73k| v->end = v->stor_begin + size; 147| | 148| 2.73k| return IGRAPH_SUCCESS; 149| 2.73k|} igraph_vector_destroy: 408| 2.73k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) { 409| 2.73k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.73k| do { \ | | 925| 2.73k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.73k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.73k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.73k] | | ------------------ ------------------ 410| | /* vector_init() will leave stor_begin set to NULL when it fails. 411| | * We handle these cases gracefully. */ 412| 2.73k| if (v->stor_begin != NULL) { ------------------ | Branch (412:9): [True: 2.73k, False: 0] ------------------ 413| 2.73k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 2.73k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 414| | v->stor_begin = NULL; 415| 2.73k| } 416| 2.73k|} igraph_vector_capacity: 436| 33.6k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) { 437| 33.6k| return v->stor_end - v->stor_begin; 438| 33.6k|} igraph_vector_reserve: 468| 33.4k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) { 469| 33.4k| igraph_int_t current_capacity; 470| 33.4k| BASE *tmp; ------------------ | | 29| 33.4k| #define BASE igraph_real_t ------------------ 471| | 472| 33.4k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 33.4k| do { \ | | 925| 33.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 33.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 33.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 33.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 33.4k] | | ------------------ ------------------ 473| 33.4k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 33.4k| do { \ | | 925| 33.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 33.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 33.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 33.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 33.4k] | | ------------------ ------------------ 474| 33.4k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 33.4k| do { \ | | 925| 33.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 33.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 33.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 33.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 33.4k] | | ------------------ ------------------ 475| | 476| 33.4k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 170| 33.4k| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 33.4k|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 33.4k|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 477| | 478| 33.4k| if (capacity <= current_capacity) { ------------------ | Branch (478:9): [True: 32.2k, False: 1.21k] ------------------ 479| 32.2k| return IGRAPH_SUCCESS; 480| 32.2k| } 481| | 482| 1.21k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 35| 1.21k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 2.42k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 1.21k, False: 0] | | | | | Branch (31:24): [True: 1.21k, False: 0] | | | | | Branch (31:66): [True: 1.21k, False: 0] | | | | ------------------ | | ------------------ ------------------ 483| 1.21k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 709| 1.21k| do { \ | | 710| 1.21k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.21k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.21k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 1.21k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.21k] | | ------------------ ------------------ 484| | 485| 1.21k| v->end = tmp + (v->end - v->stor_begin); 486| 1.21k| v->stor_begin = tmp; 487| 1.21k| v->stor_end = v->stor_begin + capacity; 488| | 489| 1.21k| return IGRAPH_SUCCESS; 490| 1.21k|} igraph_vector_size: 522| 37.3k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) { 523| 37.3k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 37.3k| do { \ | | 925| 37.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 37.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 37.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 37.3k] | | ------------------ ------------------ 524| 37.3k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 37.3k| do { \ | | 925| 37.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 37.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 37.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 37.3k] | | ------------------ ------------------ 525| 37.3k| return v->end - v->stor_begin; 526| 37.3k|} igraph_vector_push_back: 573| 34.3k|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) { 574| 34.3k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 34.3k| do { \ | | 925| 34.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 34.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 34.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 34.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 34.3k] | | ------------------ ------------------ 575| 34.3k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 34.3k| do { \ | | 925| 34.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 34.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 34.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 34.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 34.3k] | | ------------------ ------------------ 576| | 577| 34.3k| if (v->stor_end == v->end) { ------------------ | Branch (577:9): [True: 647, False: 33.6k] ------------------ 578| | /* full, allocate more storage */ 579| 647| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 170| 647| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 647|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 647|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 580| 647| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 647|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 647|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (580:33): [True: 647, False: 0] ------------------ 581| 647| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 647|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (581:13): [True: 0, False: 647] ------------------ 582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 583| 0| } 584| 647| if (new_size == 0) { ------------------ | Branch (584:13): [True: 0, False: 647] ------------------ 585| 0| new_size = 1; 586| 0| } 587| 647| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 647| do { \ | | 657| 647| igraph_error_t igraph_i_ret = (expr); \ | | 658| 647| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 647| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 647] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 647| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 647] | | ------------------ ------------------ 588| 647| } 589| | 590| 34.3k| *(v->end) = e; 591| 34.3k| v->end += 1; 592| | 593| 34.3k| return IGRAPH_SUCCESS; 594| 34.3k|} igraph_vector_resize: 1264| 32.6k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) { 1265| 32.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 32.6k| do { \ | | 925| 32.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 32.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 32.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 32.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 32.6k] | | ------------------ ------------------ 1266| 32.6k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 32.6k| do { \ | | 925| 32.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 32.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 32.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 32.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 32.6k] | | ------------------ ------------------ 1267| 32.6k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 32.6k| do { \ | | 657| 32.6k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 32.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 32.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 32.6k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 32.6k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 32.6k] | | ------------------ ------------------ 1268| 32.6k| v->end = v->stor_begin + new_size; 1269| 32.6k| return IGRAPH_SUCCESS; 1270| 32.6k|} igraph_vector_append: 2427| 148| const TYPE(igraph_vector) *from) { 2428| 148| IGRAPH_ASSERT(to != NULL); ------------------ | | 924| 148| do { \ | | 925| 148| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 148| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 148] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 148| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 148] | | ------------------ ------------------ 2429| 148| IGRAPH_ASSERT(to->stor_begin != NULL); ------------------ | | 924| 148| do { \ | | 925| 148| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 148| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 148] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 148| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 148] | | ------------------ ------------------ 2430| | 2431| 148| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to); ------------------ | | 170| 148| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 148|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 148|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2432| 148| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from); ------------------ | | 170| 148| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 148|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 148|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2433| 148| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to); ------------------ | | 170| 148| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 148|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 148|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2434| 148| igraph_int_t new_to_size; 2435| | 2436| 148| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 148| do { \ | | 48| 148| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 148| igraph_int_t _safe_sum; \ | | 50| 148| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 148] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 464| 0| do { \ | | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 467| 0| return igraph_errno; \ | | | | 468| 0| } while (0) | | | | ------------------ | | | | | Branch (468:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 148| *(res) = _safe_sum; \ | | 54| 148| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 148] | | ------------------ ------------------ 2437| | 2438| 148| if (to_capacity < new_to_size) { ------------------ | Branch (2438:9): [True: 142, False: 6] ------------------ 2439| 142| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 142|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 142|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (2439:40): [True: 142, False: 0] ------------------ 2440| 142| if (new_to_capacity < new_to_size) { ------------------ | Branch (2440:13): [True: 139, False: 3] ------------------ 2441| 139| new_to_capacity = new_to_size; 2442| 139| } 2443| 142| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity)); ------------------ | | 656| 142| do { \ | | 657| 142| igraph_error_t igraph_i_ret = (expr); \ | | 658| 142| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 142| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 142] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 142| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 142] | | ------------------ ------------------ 2444| 142| } 2445| | 2446| 148| memcpy(to->stor_begin + to_size, from->stor_begin, 2447| 148| sizeof(BASE) * from_size); 2448| 148| to->end = to->stor_begin + new_to_size; 2449| | 2450| 148| return IGRAPH_SUCCESS; 2451| 148|} igraph_vector_swap: 2541| 262|void FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) { 2542| | 2543| 262| TYPE(igraph_vector) tmp; ------------------ | | 171| 262| #define TYPE(a) CONCAT2(a,t) | | ------------------ | | | | 20| 262|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 262|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2544| | 2545| 262| tmp = *v1; 2546| 262| *v1 = *v2; 2547| 262| *v2 = tmp; 2548| 262|} igraph_vector_int_init: 134| 20.8k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) { 135| 20.8k| igraph_int_t alloc_size; 136| 20.8k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 20.8k| do { \ | | 925| 20.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 20.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 20.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 20.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 20.8k] | | ------------------ ------------------ 137| 20.8k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (137:18): [True: 11.5k, False: 9.24k] ------------------ 138| | 139| | /* When this function fails, it should leave stor_begin set to NULL, 140| | * so that vector_destroy() is still safe to call on the vector. 141| | * This simplifies freeing partially initialized data structures, 142| | * such as adjacency lists, when an error occurs mid-initialization. */ 143| 20.8k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 33| 20.8k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 41.6k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 20.8k, False: 0] | | | | | Branch (31:24): [True: 20.8k, False: 0] | | | | | Branch (31:66): [True: 20.8k, False: 0] | | | | ------------------ | | ------------------ ------------------ 144| 20.8k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector."); ------------------ | | 709| 20.8k| do { \ | | 710| 20.8k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 20.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 20.8k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 20.8k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 20.8k] | | ------------------ ------------------ 145| 20.8k| v->stor_end = v->stor_begin + alloc_size; 146| 20.8k| v->end = v->stor_begin + size; 147| | 148| 20.8k| return IGRAPH_SUCCESS; 149| 20.8k|} igraph_vector_int_destroy: 408| 20.8k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) { 409| 20.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 20.8k| do { \ | | 925| 20.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 20.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 20.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 20.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 20.8k] | | ------------------ ------------------ 410| | /* vector_init() will leave stor_begin set to NULL when it fails. 411| | * We handle these cases gracefully. */ 412| 20.8k| if (v->stor_begin != NULL) { ------------------ | Branch (412:9): [True: 20.8k, False: 0] ------------------ 413| 20.8k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 20.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 414| | v->stor_begin = NULL; 415| 20.8k| } 416| 20.8k|} igraph_vector_int_capacity: 436| 17.5k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) { 437| 17.5k| return v->stor_end - v->stor_begin; 438| 17.5k|} igraph_vector_int_reserve: 468| 17.5k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) { 469| 17.5k| igraph_int_t current_capacity; 470| 17.5k| BASE *tmp; ------------------ | | 66| 17.5k| #define BASE igraph_int_t ------------------ 471| | 472| 17.5k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 17.5k| do { \ | | 925| 17.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.5k] | | ------------------ ------------------ 473| 17.5k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 17.5k| do { \ | | 925| 17.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.5k] | | ------------------ ------------------ 474| 17.5k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 17.5k| do { \ | | 925| 17.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.5k] | | ------------------ ------------------ 475| | 476| 17.5k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 178| 17.5k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 17.5k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 17.5k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 477| | 478| 17.5k| if (capacity <= current_capacity) { ------------------ | Branch (478:9): [True: 7.20k, False: 10.3k] ------------------ 479| 7.20k| return IGRAPH_SUCCESS; 480| 7.20k| } 481| | 482| 10.3k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 35| 10.3k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 20.6k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 10.3k, False: 0] | | | | | Branch (31:24): [True: 10.3k, False: 0] | | | | | Branch (31:66): [True: 10.3k, False: 0] | | | | ------------------ | | ------------------ ------------------ 483| 10.3k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 709| 10.3k| do { \ | | 710| 10.3k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 10.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.3k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 10.3k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 10.3k] | | ------------------ ------------------ 484| | 485| 10.3k| v->end = tmp + (v->end - v->stor_begin); 486| 10.3k| v->stor_begin = tmp; 487| 10.3k| v->stor_end = v->stor_begin + capacity; 488| | 489| 10.3k| return IGRAPH_SUCCESS; 490| 10.3k|} igraph_vector_int_empty: 503| 599|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector) *v) { 504| 599| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 599| do { \ | | 925| 599| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 599] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 599| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 599] | | ------------------ ------------------ 505| 599| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 599| do { \ | | 925| 599| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 599] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 599| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 599] | | ------------------ ------------------ 506| 599| return v->stor_begin == v->end; 507| 599|} igraph_vector_int_size: 522| 53.8k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) { 523| 53.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 53.8k| do { \ | | 925| 53.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 53.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 53.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 53.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 53.8k] | | ------------------ ------------------ 524| 53.8k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 53.8k| do { \ | | 925| 53.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 53.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 53.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 53.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 53.8k] | | ------------------ ------------------ 525| 53.8k| return v->end - v->stor_begin; 526| 53.8k|} igraph_vector_int_push_back: 573| 14.7M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) { 574| 14.7M| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 14.7M| do { \ | | 925| 14.7M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 14.7M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 14.7M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 14.7M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 14.7M] | | ------------------ ------------------ 575| 14.7M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 14.7M| do { \ | | 925| 14.7M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 14.7M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 14.7M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 14.7M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 14.7M] | | ------------------ ------------------ 576| | 577| 14.7M| if (v->stor_end == v->end) { ------------------ | Branch (577:9): [True: 7.67k, False: 14.7M] ------------------ 578| | /* full, allocate more storage */ 579| 7.67k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 178| 7.67k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 7.67k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 7.67k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 580| 7.67k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.67k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.67k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (580:33): [True: 7.67k, False: 0] ------------------ 581| 7.67k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 7.67k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (581:13): [True: 0, False: 7.67k] ------------------ 582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 583| 0| } 584| 7.67k| if (new_size == 0) { ------------------ | Branch (584:13): [True: 0, False: 7.67k] ------------------ 585| 0| new_size = 1; 586| 0| } 587| 7.67k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 7.67k| do { \ | | 657| 7.67k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 7.67k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 7.67k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.67k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 7.67k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 7.67k] | | ------------------ ------------------ 588| 7.67k| } 589| | 590| 14.7M| *(v->end) = e; 591| 14.7M| v->end += 1; 592| | 593| 14.7M| return IGRAPH_SUCCESS; 594| 14.7M|} igraph_vector_int_null: 725| 2.28k|void FUNCTION(igraph_vector, null)(TYPE(igraph_vector) *v) { 726| 2.28k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.28k| do { \ | | 925| 2.28k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.28k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.28k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.28k] | | ------------------ ------------------ 727| 2.28k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 2.28k| do { \ | | 925| 2.28k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.28k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.28k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.28k] | | ------------------ ------------------ 728| 2.28k| if (FUNCTION(igraph_vector, size)(v) > 0) { ------------------ | | 178| 2.28k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 2.28k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 2.28k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ | Branch (728:9): [True: 1.99k, False: 296] ------------------ 729| 1.99k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v)); ------------------ | | 178| 1.99k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 1.99k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 1.99k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 730| 1.99k| } 731| 2.28k|} igraph_vector_int_resize: 1264| 5.57k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) { 1265| 5.57k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 5.57k| do { \ | | 925| 5.57k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 5.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.57k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 5.57k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 5.57k] | | ------------------ ------------------ 1266| 5.57k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 5.57k| do { \ | | 925| 5.57k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 5.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.57k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 5.57k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 5.57k] | | ------------------ ------------------ 1267| 5.57k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 5.57k| do { \ | | 657| 5.57k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 5.57k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 5.57k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.57k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 5.57k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 5.57k] | | ------------------ ------------------ 1268| 5.57k| v->end = v->stor_begin + new_size; 1269| 5.57k| return IGRAPH_SUCCESS; 1270| 5.57k|} igraph_vector_int_max: 1327| 599|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector) *v) { 1328| 599| BASE max; ------------------ | | 66| 599| #define BASE igraph_int_t ------------------ 1329| 599| BASE *ptr; ------------------ | | 66| 599| #define BASE igraph_int_t ------------------ 1330| 599| IGRAPH_ASSERT(!FUNCTION(igraph_vector, empty)(v)); ------------------ | | 924| 599| do { \ | | 925| 599| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 599| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 599] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 599| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 599] | | ------------------ ------------------ 1331| 599| max = *(v->stor_begin); 1332| |#if defined(BASE_IGRAPH_REAL) 1333| | if (isnan(max)) { return max; }; /* Result is NaN */ 1334| |#endif 1335| 599| ptr = v->stor_begin + 1; 1336| 7.39M| while (ptr < v->end) { ------------------ | Branch (1336:12): [True: 7.39M, False: 599] ------------------ 1337| 7.39M| if ((*ptr) > max) { ------------------ | Branch (1337:13): [True: 34.1k, False: 7.35M] ------------------ 1338| 34.1k| max = *ptr; 1339| 34.1k| } 1340| |#if defined(BASE_IGRAPH_REAL) 1341| | else if (isnan(*ptr)) 1342| | return *ptr; /* Result is NaN */ 1343| |#endif 1344| 7.39M| ptr++; 1345| 7.39M| } 1346| 599| return max; 1347| 599|} igraph_vector_int_isininterval: 1832| 690| BASE high) { 1833| 690| BASE *ptr; ------------------ | | 66| 690| #define BASE igraph_int_t ------------------ 1834| 690| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 690| do { \ | | 925| 690| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 690| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 690] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 690| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 690] | | ------------------ ------------------ 1835| 690| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 690| do { \ | | 925| 690| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 690| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 690] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 690| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 690] | | ------------------ ------------------ 1836| 7.02M| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (1836:31): [True: 7.02M, False: 498] ------------------ 1837| | /* Note that the following is not equivalent to *ptr < low || *ptr > high 1838| | * when *ptr is NaN! */ 1839| 7.02M| if (!(*ptr >= low && *ptr <= high)) { ------------------ | Branch (1839:15): [True: 7.02M, False: 0] | Branch (1839:30): [True: 7.02M, False: 192] ------------------ 1840| 192| return 0; 1841| 192| } 1842| 7.02M| } 1843| 498| return 1; 1844| 690|} igraph_vector_ptr_init: 86| 10.5k|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_int_t size) { 87| 10.5k| igraph_int_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (87:31): [True: 8.21k, False: 2.32k] ------------------ 88| 10.5k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 10.5k| do { \ | | 925| 10.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 10.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 10.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 10.5k] | | ------------------ ------------------ 89| 10.5k| if (size < 0) { ------------------ | Branch (89:9): [True: 0, False: 10.5k] ------------------ 90| 0| size = 0; 91| 0| } 92| 10.5k| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*); ------------------ | | 33| 10.5k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 21.0k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 10.5k, False: 0] | | | | | Branch (31:24): [True: 10.5k, False: 0] | | | | | Branch (31:66): [True: 10.5k, False: 0] | | | | ------------------ | | ------------------ ------------------ 93| 10.5k| if (v->stor_begin == 0) { ------------------ | Branch (93:9): [True: 0, False: 10.5k] ------------------ 94| 0| IGRAPH_ERROR("vector ptr init failed", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 95| 0| } 96| 10.5k| v->stor_end = v->stor_begin + alloc_size; 97| 10.5k| v->end = v->stor_begin + size; 98| 10.5k| v->item_destructor = 0; 99| | 100| 10.5k| return IGRAPH_SUCCESS; 101| 10.5k|} igraph_vector_ptr_destroy: 132| 10.5k|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) { 133| 10.5k| IGRAPH_ASSERT(v != 0); ------------------ | | 924| 10.5k| do { \ | | 925| 10.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 10.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 10.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 10.5k] | | ------------------ ------------------ 134| 10.5k| if (v->stor_begin != 0) { ------------------ | Branch (134:9): [True: 10.5k, False: 0] ------------------ 135| 10.5k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 10.5k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 136| | v->stor_begin = NULL; 137| 10.5k| } 138| 10.5k|} igraph_vector_ptr_reserve: 215| 3.49k|igraph_error_t igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, igraph_int_t capacity) { 216| 3.49k| igraph_int_t actual_size = igraph_vector_ptr_size(v); 217| 3.49k| void **tmp; 218| 3.49k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 3.49k| do { \ | | 925| 3.49k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.49k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.49k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.49k] | | ------------------ ------------------ 219| 3.49k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 3.49k| do { \ | | 925| 3.49k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.49k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.49k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.49k] | | ------------------ ------------------ 220| 3.49k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 3.49k| do { \ | | 925| 3.49k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.49k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.49k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.49k] | | ------------------ ------------------ 221| | 222| 3.49k| if (capacity <= igraph_vector_ptr_size(v)) { ------------------ | Branch (222:9): [True: 0, False: 3.49k] ------------------ 223| 0| return IGRAPH_SUCCESS; 224| 0| } 225| | 226| 3.49k| tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) capacity, void*); ------------------ | | 35| 3.49k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 6.98k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 3.49k, False: 0] | | | | | Branch (31:24): [True: 3.49k, False: 0] | | | | | Branch (31:66): [True: 3.49k, False: 0] | | | | ------------------ | | ------------------ ------------------ 227| 3.49k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for pointer vector."); ------------------ | | 709| 3.49k| do { \ | | 710| 3.49k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.49k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 3.49k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.49k] | | ------------------ ------------------ 228| | 229| 3.49k| v->stor_begin = tmp; 230| 3.49k| v->stor_end = v->stor_begin + capacity; 231| 3.49k| v->end = v->stor_begin + actual_size; 232| | 233| 3.49k| return IGRAPH_SUCCESS; 234| 3.49k|} igraph_vector_ptr_size: 291| 17.5k|igraph_int_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) { 292| 17.5k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 17.5k| do { \ | | 925| 17.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.5k] | | ------------------ ------------------ 293| 17.5k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 17.5k| do { \ | | 925| 17.5k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.5k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.5k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.5k] | | ------------------ ------------------ 294| 17.5k| return v->end - v->stor_begin; 295| 17.5k|} igraph_vector_ptr_push_back: 360| 11.3k|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) { 361| 11.3k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 11.3k| do { \ | | 925| 11.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 11.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 11.3k] | | ------------------ ------------------ 362| 11.3k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 11.3k| do { \ | | 925| 11.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 11.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 11.3k] | | ------------------ ------------------ 363| | 364| | /* full, allocate more storage */ 365| 11.3k| if (v->stor_end == v->end) { ------------------ | Branch (365:9): [True: 3.49k, False: 7.82k] ------------------ 366| 3.49k| igraph_int_t new_size = igraph_vector_ptr_size(v) * 2; 367| 3.49k| if (new_size == 0) { ------------------ | Branch (367:13): [True: 0, False: 3.49k] ------------------ 368| 0| new_size = 1; 369| 0| } 370| 3.49k| IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size)); ------------------ | | 656| 3.49k| do { \ | | 657| 3.49k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.49k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.49k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.49k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.49k] | | ------------------ ------------------ 371| 3.49k| } 372| | 373| 11.3k| *(v->end) = e; 374| 11.3k| v->end += 1; 375| | 376| 11.3k| return IGRAPH_SUCCESS; 377| 11.3k|} igraph_attribute_record_init: 126| 754|) { 127| 754| attr->name = NULL; 128| 754| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 129| 754| attr->value.as_raw = NULL; 130| 754| attr->default_value.string = NULL; 131| | 132| 754| IGRAPH_CHECK(igraph_attribute_record_set_name(attr, name)); ------------------ | | 656| 754| do { \ | | 657| 754| igraph_error_t igraph_i_ret = (expr); \ | | 658| 754| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 754| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 754] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 754| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 754] | | ------------------ ------------------ 133| 754| IGRAPH_FINALLY(igraph_free, attr->name); ------------------ | | 603| 754| do { \ | | 604| 754| /* the following branch makes the compiler check the compatibility of \ | | 605| 754| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 754| * incorrect destructor function with the pointer */ \ | | 607| 754| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 754] | | ------------------ | | 608| 754| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 754| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 754] | | ------------------ ------------------ 134| 754| IGRAPH_CHECK(igraph_attribute_record_set_type(attr, type)); ------------------ | | 656| 754| do { \ | | 657| 754| igraph_error_t igraph_i_ret = (expr); \ | | 658| 754| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 754| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 754] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 754| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 754] | | ------------------ ------------------ 135| 754| IGRAPH_FINALLY_CLEAN(1); 136| | 137| 754| return IGRAPH_SUCCESS; 138| 754|} igraph_attribute_record_destroy: 241| 754|void igraph_attribute_record_destroy(igraph_attribute_record_t *attr) { 242| 754| igraph_i_attribute_record_destroy_values(attr); 243| | 244| 754| if (attr->name) { ------------------ | Branch (244:9): [True: 754, False: 0] ------------------ 245| 754| igraph_free(attr->name); 246| | attr->name = NULL; 247| 754| } 248| 754|} igraph_attribute_record_size: 295| 640|igraph_int_t igraph_attribute_record_size(const igraph_attribute_record_t *attr) { 296| 640| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 640| do { \ | | 925| 640| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 640| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 640] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 640| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 640] | | ------------------ ------------------ 297| | 298| 640| switch (attr->type) { 299| 296| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (299:9): [True: 296, False: 344] ------------------ 300| 296| return igraph_vector_size(attr->value.as_vector); 301| | 302| 344| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (302:9): [True: 344, False: 296] ------------------ 303| 344| return igraph_strvector_size(attr->value.as_strvector); 304| | 305| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (305:9): [True: 0, False: 640] ------------------ 306| 0| return igraph_vector_bool_size(attr->value.as_vector_bool); 307| | 308| 0| case IGRAPH_ATTRIBUTE_UNSPECIFIED: ------------------ | Branch (308:9): [True: 0, False: 640] ------------------ 309| 0| return 0; 310| | 311| 0| default: ------------------ | Branch (311:9): [True: 0, False: 640] ------------------ 312| 0| IGRAPH_ERRORF("Unsupported attribute type: %d", IGRAPH_EINVAL, (int) attr->type); ------------------ | | 464| 0| do { \ | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | 467| 0| return igraph_errno; \ | | 468| 0| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 313| 640| } 314| 640|} igraph_attribute_record_resize: 332| 137|) { 333| 137| igraph_int_t i; 334| 137| igraph_vector_t *vec; 335| 137| igraph_vector_bool_t *log; 336| 137| igraph_strvector_t *str; 337| | 338| 137| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 137| do { \ | | 925| 137| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 137| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 137] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 137| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 137] | | ------------------ ------------------ 339| | 340| 137| switch (attr->type) { 341| | 342| 0| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (342:9): [True: 0, False: 137] ------------------ 343| 0| vec = attr->value.as_vector; 344| 0| i = igraph_vector_size(vec); 345| 0| IGRAPH_CHECK(igraph_vector_resize(vec, new_size)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 346| 0| while (i < new_size) { ------------------ | Branch (346:20): [True: 0, False: 0] ------------------ 347| 0| VECTOR(*vec)[i++] = attr->default_value.numeric; ------------------ | | 60| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 348| 0| } 349| 0| break; 350| | 351| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (351:9): [True: 0, False: 137] ------------------ 352| 0| log = attr->value.as_vector_bool; 353| 0| i = igraph_vector_bool_size(log); 354| 0| IGRAPH_CHECK(igraph_vector_bool_resize(log, new_size)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 355| 0| while (i < new_size) { ------------------ | Branch (355:20): [True: 0, False: 0] ------------------ 356| 0| VECTOR(*log)[i++] = attr->default_value.boolean; ------------------ | | 60| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 357| 0| } 358| 0| break; 359| | 360| 137| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (360:9): [True: 137, False: 0] ------------------ 361| 137| str = attr->value.as_strvector; 362| 137| if (attr->default_value.string == 0 || (*attr->default_value.string == 0)) { ------------------ | Branch (362:17): [True: 137, False: 0] | Branch (362:52): [True: 0, False: 0] ------------------ 363| 137| IGRAPH_CHECK(igraph_strvector_resize(str, new_size)); ------------------ | | 656| 137| do { \ | | 657| 137| igraph_error_t igraph_i_ret = (expr); \ | | 658| 137| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 137| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 137] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 137| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 137] | | ------------------ ------------------ 364| 137| } else { 365| 0| i = igraph_strvector_size(str); 366| 0| IGRAPH_CHECK(igraph_strvector_resize(str, new_size)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 367| 0| while (i < new_size) { ------------------ | Branch (367:24): [True: 0, False: 0] ------------------ 368| 0| IGRAPH_CHECK(igraph_strvector_set(str, i++, attr->default_value.string)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 369| 0| } 370| 0| } 371| 137| break; 372| | 373| 137| case IGRAPH_ATTRIBUTE_UNSPECIFIED: ------------------ | Branch (373:9): [True: 0, False: 137] ------------------ 374| 0| IGRAPH_ERROR("Attribute record has no type yet.", IGRAPH_EINVAL); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 375| 0| break; 376| | 377| 0| default: ------------------ | Branch (377:9): [True: 0, False: 137] ------------------ 378| 0| IGRAPH_ERRORF("Unsupported attribute type: %d", IGRAPH_EINVAL, (int) attr->type); ------------------ | | 464| 0| do { \ | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | 467| 0| return igraph_errno; \ | | 468| 0| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 379| 137| } 380| | 381| 137| return IGRAPH_SUCCESS; 382| 137|} igraph_attribute_record_set_default_numeric: 399| 410|) { 400| 410| if (attr->type != IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (400:9): [True: 0, False: 410] ------------------ 401| 0| return IGRAPH_EINVAL; 402| 0| } 403| | 404| 410| attr->default_value.numeric = value; 405| 410| return IGRAPH_SUCCESS; 406| 410|} igraph_attribute_record_set_name: 483| 1.50k|) { 484| 1.50k| char *new_name; 485| | 486| 1.50k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.50k| do { \ | | 925| 1.50k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.50k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.50k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.50k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.50k] | | ------------------ ------------------ 487| | 488| 1.50k| if (name != NULL) { ------------------ | Branch (488:9): [True: 754, False: 754] ------------------ 489| 754| new_name = strdup(name); 490| 754| IGRAPH_CHECK_OOM(new_name, "Insufficient memory for allocating attribute name."); ------------------ | | 709| 754| do { \ | | 710| 754| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 754| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 754] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 754| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 754] | | ------------------ ------------------ 491| 754| } else { 492| 754| new_name = NULL; 493| 754| } 494| | 495| 1.50k| if (attr->name) { ------------------ | Branch (495:9): [True: 0, False: 1.50k] ------------------ 496| 0| igraph_free(attr->name); 497| 0| } 498| | 499| 1.50k| attr->name = new_name; 500| | 501| 1.50k| return IGRAPH_SUCCESS; 502| 1.50k|} igraph_attribute_record_set_type: 539| 1.50k|) { 540| 1.50k| void *ptr; 541| | 542| 1.50k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.50k| do { \ | | 925| 1.50k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.50k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.50k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.50k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.50k] | | ------------------ ------------------ 543| | 544| 1.50k| if (attr->type != type) { ------------------ | Branch (544:9): [True: 754, False: 754] ------------------ 545| 754| switch (type) { 546| 410| case IGRAPH_ATTRIBUTE_NUMERIC: { ------------------ | Branch (546:13): [True: 410, False: 344] ------------------ 547| 410| igraph_vector_t *vec = IGRAPH_CALLOC(1, igraph_vector_t); ------------------ | | 33| 410|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 820| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 410, Folded] | | | | ------------------ | | ------------------ ------------------ 548| 410| IGRAPH_CHECK_OOM(vec, "Insufficient memory for attribute record."); ------------------ | | 709| 410| do { \ | | 710| 410| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 410| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 410] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 410| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 410] | | ------------------ ------------------ 549| 410| IGRAPH_FINALLY(igraph_free, vec); ------------------ | | 603| 410| do { \ | | 604| 410| /* the following branch makes the compiler check the compatibility of \ | | 605| 410| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 410| * incorrect destructor function with the pointer */ \ | | 607| 410| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 410] | | ------------------ | | 608| 410| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 410| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 410] | | ------------------ ------------------ 550| 410| IGRAPH_VECTOR_INIT_FINALLY(vec, 0); ------------------ | | 104| 410| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 656| 410| do { \ | | | | 657| 410| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 410| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 410| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 410] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 410| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 410] | | | | ------------------ | | ------------------ | | 105| 410| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 603| 410| do { \ | | | | 604| 410| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 410| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 410| * incorrect destructor function with the pointer */ \ | | | | 607| 410| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 410] | | | | ------------------ | | | | 608| 410| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 410| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 410] | | | | ------------------ | | ------------------ | | | Branch (105:60): [Folded, False: 410] | | ------------------ ------------------ 551| 410| ptr = vec; 552| 410| } 553| 0| break; 554| | 555| 344| case IGRAPH_ATTRIBUTE_STRING: { ------------------ | Branch (555:13): [True: 344, False: 410] ------------------ 556| 344| igraph_strvector_t *strvec = IGRAPH_CALLOC(1, igraph_strvector_t); ------------------ | | 33| 344|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 688| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 344, Folded] | | | | ------------------ | | ------------------ ------------------ 557| 344| IGRAPH_CHECK_OOM(strvec, "Insufficient memory for attribute record."); ------------------ | | 709| 344| do { \ | | 710| 344| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 344] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 344| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 344] | | ------------------ ------------------ 558| 344| IGRAPH_FINALLY(igraph_free, strvec); ------------------ | | 603| 344| do { \ | | 604| 344| /* the following branch makes the compiler check the compatibility of \ | | 605| 344| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 344| * incorrect destructor function with the pointer */ \ | | 607| 344| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 344] | | ------------------ | | 608| 344| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 344| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 344] | | ------------------ ------------------ 559| 344| IGRAPH_STRVECTOR_INIT_FINALLY(strvec, 0); ------------------ | | 62| 344| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 344| do { \ | | | | 657| 344| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 344| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 344| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 344] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 344| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 344] | | | | ------------------ | | ------------------ | | 63| 344| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 344| do { \ | | | | 604| 344| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 344| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 344| * incorrect destructor function with the pointer */ \ | | | | 607| 344| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 344] | | | | ------------------ | | | | 608| 344| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 344| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 344] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 344] | | ------------------ ------------------ 560| 344| ptr = strvec; 561| 344| } 562| 0| break; 563| | 564| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: { ------------------ | Branch (564:13): [True: 0, False: 754] ------------------ 565| 0| igraph_vector_bool_t *boolvec = IGRAPH_CALLOC(1, igraph_vector_bool_t); ------------------ | | 33| 0|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 0| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 0, Folded] | | | | ------------------ | | ------------------ ------------------ 566| 0| IGRAPH_CHECK_OOM(boolvec, "Insufficient memory for attribute record."); ------------------ | | 709| 0| do { \ | | 710| 0| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 0| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 0] | | ------------------ ------------------ 567| 0| IGRAPH_FINALLY(igraph_free, boolvec); ------------------ | | 603| 0| do { \ | | 604| 0| /* the following branch makes the compiler check the compatibility of \ | | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 0| * incorrect destructor function with the pointer */ \ | | 607| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 0] | | ------------------ | | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 0| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 0] | | ------------------ ------------------ 568| 0| IGRAPH_VECTOR_BOOL_INIT_FINALLY(boolvec, 0); ------------------ | | 109| 0| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \ | | ------------------ | | | | 656| 0| do { \ | | | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 0| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 110| 0| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0) | | ------------------ | | | | 603| 0| do { \ | | | | 604| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 0| * incorrect destructor function with the pointer */ \ | | | | 607| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 0] | | | | ------------------ | | | | 608| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 0| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | | Branch (110:65): [Folded, False: 0] | | ------------------ ------------------ 569| 0| ptr = boolvec; 570| 0| } 571| 0| break; 572| | 573| 0| default: ------------------ | Branch (573:13): [True: 0, False: 754] ------------------ 574| 0| IGRAPH_FATALF("Unsupported attribute type: %d.", (int) type); ------------------ | | 875| 0| do { \ | | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 877| 0| __VA_ARGS__); \ | | 878| 0| } while (0) | | ------------------ | | | Branch (878:14): [Folded, False: 0] | | ------------------ ------------------ 575| 754| } 576| | 577| 754| igraph_i_attribute_record_set_type(attr, type, ptr); 578| 754| IGRAPH_FINALLY_CLEAN(2); 579| 754| } 580| | 581| 1.50k| return IGRAPH_SUCCESS; 582| 1.50k|} igraph_i_attribute_init: 617| 827|) { 618| 827| graph->attr = NULL; 619| 827| if (igraph_i_attribute_table) { ------------------ | Branch (619:9): [True: 827, False: 0] ------------------ 620| 827| IGRAPH_CHECK(igraph_i_attribute_table->init(graph, attr)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 621| 827| if (graph->attr == NULL) { ------------------ | Branch (621:13): [True: 0, False: 827] ------------------ 622| 0| IGRAPH_ERROR("Attribute handler did not initialize attr pointer", IGRAPH_FAILURE); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 623| 0| } 624| 827| } 625| 827| return IGRAPH_SUCCESS; 626| 827|} igraph_i_attribute_destroy: 628| 827|void igraph_i_attribute_destroy(igraph_t *graph) { 629| 827| if (graph->attr && igraph_i_attribute_table) { ------------------ | Branch (629:9): [True: 827, False: 0] | Branch (629:24): [True: 827, False: 0] ------------------ 630| 827| igraph_i_attribute_table->destroy(graph); 631| 827| } 632| | graph->attr = NULL; 633| 827|} igraph_i_attribute_add_vertices: 649| 1.65k|) { 650| 1.65k| if (igraph_i_attribute_table) { ------------------ | Branch (650:9): [True: 1.65k, False: 0] ------------------ 651| 1.65k| return igraph_i_attribute_table->add_vertices(graph, nv, attr); 652| 1.65k| } else { 653| 0| return IGRAPH_SUCCESS; 654| 0| } 655| 1.65k|} igraph_i_attribute_add_edges: 690| 498|) { 691| 498| if (igraph_i_attribute_table) { ------------------ | Branch (691:9): [True: 498, False: 0] ------------------ 692| 498| return igraph_i_attribute_table->add_edges(graph, edges, attr); 693| 498| } else { 694| 0| return IGRAPH_SUCCESS; 695| 0| } 696| 498|} igraph_set_attribute_table: 895| 2.32k|igraph_set_attribute_table(const igraph_attribute_table_t * table) { 896| 2.32k| igraph_attribute_table_t *old = igraph_i_attribute_table; 897| 2.32k| igraph_i_attribute_table = (igraph_attribute_table_t*) table; 898| 2.32k| return old; 899| 2.32k|} attributes.c:igraph_i_attribute_record_destroy_values: 185| 1.50k|static void igraph_i_attribute_record_destroy_values(igraph_attribute_record_t *attr) { 186| 1.50k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.50k| do { \ | | 925| 1.50k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.50k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.50k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.50k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.50k] | | ------------------ ------------------ 187| | 188| 1.50k| if (attr->value.as_raw) { ------------------ | Branch (188:9): [True: 754, False: 754] ------------------ 189| 754| switch (attr->type) { 190| 410| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (190:13): [True: 410, False: 344] ------------------ 191| 410| igraph_vector_destroy(attr->value.as_vector); 192| 410| break; 193| | 194| 344| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (194:13): [True: 344, False: 410] ------------------ 195| 344| igraph_strvector_destroy(attr->value.as_strvector); 196| 344| break; 197| | 198| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (198:13): [True: 0, False: 754] ------------------ 199| 0| igraph_vector_bool_destroy(attr->value.as_vector_bool); 200| 0| break; 201| | 202| 0| default: ------------------ | Branch (202:13): [True: 0, False: 754] ------------------ 203| 0| break; 204| 754| } 205| | 206| 754| igraph_free(attr->value.as_raw); 207| 754| attr->value.as_raw = NULL; 208| 754| } 209| | 210| 1.50k| switch (attr->type) { 211| 410| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (211:9): [True: 410, False: 1.09k] ------------------ 212| 410| attr->default_value.numeric = 0; 213| 410| break; 214| | 215| 344| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (215:9): [True: 344, False: 1.16k] ------------------ 216| 344| if (attr->default_value.string) { ------------------ | Branch (216:17): [True: 0, False: 344] ------------------ 217| 0| igraph_free(attr->default_value.string); 218| 0| attr->default_value.string = NULL; 219| 0| } 220| 344| break; 221| | 222| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (222:9): [True: 0, False: 1.50k] ------------------ 223| 0| attr->default_value.boolean = 0; 224| 0| break; 225| | 226| 754| default: ------------------ | Branch (226:9): [True: 754, False: 754] ------------------ 227| 754| break; 228| 1.50k| } 229| | 230| 1.50k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 231| 1.50k|} attributes.c:igraph_i_attribute_record_set_type: 506| 754|) { 507| 754| bool type_changed = attr->type != type; 508| | 509| 754| if (type_changed || attr->value.as_raw != ptr) { ------------------ | Branch (509:9): [True: 754, False: 0] | Branch (509:25): [True: 0, False: 0] ------------------ 510| 754| igraph_i_attribute_record_destroy_values(attr); 511| 754| attr->type = type; 512| 754| attr->value.as_raw = ptr; 513| 754| } 514| | 515| 754| if (type_changed && type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (515:9): [True: 754, False: 0] | Branch (515:25): [True: 410, False: 344] ------------------ 516| 410| IGRAPH_ASSERT( ------------------ | | 924| 410| do { \ | | 925| 410| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 410| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 410] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 410| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 410] | | ------------------ ------------------ 517| 410| igraph_attribute_record_set_default_numeric(attr, IGRAPH_NAN) == IGRAPH_SUCCESS 518| 410| ); 519| 410| } 520| 754|} attributes.c:igraph_i_attribute_record_list_init_item: 596| 754|) { 597| 754| IGRAPH_UNUSED(list); ------------------ | | 30| 754|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 598| | return igraph_attribute_record_init(item, NULL, IGRAPH_ATTRIBUTE_UNSPECIFIED); 599| 754|} attributes.c:igraph_i_attribute_record_list_destroy_item: 607| 754|static void igraph_i_attribute_record_list_destroy_item(igraph_attribute_record_t* item) { 608| 754| igraph_attribute_record_destroy(item); 609| 754|} igraph_i_property_cache_init: 32| 827|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) { 33| 827| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32); ------------------ | | 68| 827|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)])) ------------------ 34| | 35| 827| memset(cache->value, 0, sizeof(cache->value)); 36| 827| cache->known = 0; 37| 827| return IGRAPH_SUCCESS; 38| 827|} igraph_i_property_cache_destroy: 53| 827|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) { 54| 827| IGRAPH_UNUSED(cache); ------------------ | | 30| 827|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 55| | /* Nothing to do */ 56| 827|} igraph_i_property_cache_invalidate_conditionally: 182| 2.01k|) { 183| 2.01k| uint32_t invalidate = ~keep_always; 184| 2.01k| uint32_t mask; 185| 2.01k| uint32_t maybe_keep; 186| 2.01k| igraph_bool_t cached_value; 187| | 188| 2.01k| assert(graph->cache != NULL); ------------------ | Branch (188:5): [True: 0, False: 2.01k] | Branch (188:5): [True: 2.01k, False: 0] ------------------ 189| | 190| | /* The bits of maybe_keep are set to 1 for those properties that are: 191| | * 192| | * - currently cached 193| | * - should _probably_ be invalidated 194| | * - _but_ the current cached value of the property may change the decision 195| | */ 196| 2.01k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true); 197| | 198| 2.01k| if (maybe_keep) { ------------------ | Branch (198:9): [True: 0, False: 2.01k] ------------------ 199| 0| for (igraph_cached_property_t prop = (igraph_cached_property_t ) 0; prop < IGRAPH_PROP_I_SIZE; ++prop) { ------------------ | Branch (199:77): [True: 0, False: 0] ------------------ 200| 0| mask = 1 << prop; 201| 0| if (maybe_keep & mask) { ------------------ | Branch (201:17): [True: 0, False: 0] ------------------ 202| | /* if we get here, we know that the property is cached; we have 203| | * masked maybe_keep with graph->cache->known */ 204| 0| cached_value = igraph_i_property_cache_get_bool(graph, prop); 205| 0| if ( 206| 0| ((keep_when_false & mask) && !cached_value) || ------------------ | Branch (206:22): [True: 0, False: 0] | Branch (206:50): [True: 0, False: 0] ------------------ 207| 0| ((keep_when_true & mask) && cached_value) ------------------ | Branch (207:22): [True: 0, False: 0] | Branch (207:49): [True: 0, False: 0] ------------------ 208| 0| ) { 209| 0| invalidate &= ~mask; 210| 0| } 211| 0| } 212| 0| } 213| 0| } 214| | 215| 2.01k| graph->cache->known &= ~invalidate; 216| 2.01k|} cattributes.c:igraph_i_cattribute_init: 195| 827|) { 196| 827| igraph_i_cattributes_t *nattr; 197| | 198| 827| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t); ------------------ | | 33| 827|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 1.65k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 827, Folded] | | | | ------------------ | | ------------------ ------------------ 199| 827| IGRAPH_CHECK_OOM(nattr, "Insufficient memory to allocate attribute storage."); ------------------ | | 709| 827| do { \ | | 710| 827| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 827| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 827] | | ------------------ ------------------ 200| 827| IGRAPH_FINALLY(igraph_free, nattr); ------------------ | | 603| 827| do { \ | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 827| * incorrect destructor function with the pointer */ \ | | 607| 827| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 827] | | ------------------ | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 827| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 827] | | ------------------ ------------------ 201| | 202| 827| if (attr) { ------------------ | Branch (202:9): [True: 0, False: 827] ------------------ 203| 0| IGRAPH_CHECK(igraph_attribute_record_list_init_copy(&nattr->gal, attr)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 204| 827| } else { 205| 827| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->gal, 0)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 206| 827| } 207| 827| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->gal); ------------------ | | 603| 827| do { \ | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 827| * incorrect destructor function with the pointer */ \ | | 607| 827| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 827] | | ------------------ | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 827| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 827] | | ------------------ ------------------ 208| | 209| 827| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->val, 0)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 210| 827| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->val); ------------------ | | 603| 827| do { \ | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 827| * incorrect destructor function with the pointer */ \ | | 607| 827| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 827] | | ------------------ | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 827| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 827] | | ------------------ ------------------ 211| | 212| 827| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->eal, 0)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 213| 827| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->eal); ------------------ | | 603| 827| do { \ | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 827| * incorrect destructor function with the pointer */ \ | | 607| 827| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 827] | | ------------------ | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 827| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 827] | | ------------------ ------------------ 214| | 215| 827| graph->attr = nattr; 216| 827| IGRAPH_FINALLY_CLEAN(4); 217| | 218| 827| return IGRAPH_SUCCESS; 219| 827|} cattributes.c:igraph_i_cattribute_destroy: 221| 827|static void igraph_i_cattribute_destroy(igraph_t *graph) { 222| 827| igraph_i_cattributes_t *attr = graph->attr; 223| 827| igraph_attribute_record_list_destroy(&attr->eal); 224| 827| igraph_attribute_record_list_destroy(&attr->val); 225| 827| igraph_attribute_record_list_destroy(&attr->gal); 226| | IGRAPH_FREE(graph->attr); /* sets to NULL */ ------------------ | | 36| 827|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 227| 827|} cattributes.c:igraph_i_cattribute_add_vertices: 373| 1.65k|) { 374| 1.65k| igraph_i_cattributes_t *attr = graph->attr; 375| 1.65k| return igraph_i_cattribute_add_vertices_or_edges(&attr->val, igraph_vcount(graph), nv, nattr); 376| 1.65k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges: 344| 2.15k|) { 345| 2.15k| igraph_int_t origlen = newlen - nv; 346| 2.15k| igraph_error_t err = igraph_i_cattribute_add_vertices_or_edges_inner( 347| 2.15k| val, newlen, nv, nattr 348| 2.15k| ); 349| | 350| 2.15k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (350:9): [True: 137, False: 2.01k] ------------------ 351| | /* If unsuccessful, revert attribute vector sizes. 352| | * The following function assumes that all attributes vectors that 353| | * are present have a length at least as great as origlen. 354| | * This is true at the moment because any new attributes that are 355| | * added to the graph are created directly at 'origlen' instead of 356| | * being created at smaller sizes and resized later. 357| | * 358| | * NOTE: While this ensures that all attribute vector lengths are 359| | * correct, it does not ensure that no extra attributes have 360| | * been added to the graph. However, the presence of extra 361| | * attributes does not make the attribute table inconsistent 362| | * like the incorrect attribute vector lengths would. 363| | */ 364| 137| igraph_i_cattribute_revert_attribute_vector_sizes(val, origlen); 365| 137| } 366| | 367| 2.15k| return err; 368| 2.15k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges_inner: 269| 2.15k|) { 270| 2.15k| igraph_int_t length; 271| 2.15k| igraph_int_t nattrno = nattr == NULL ? 0 : igraph_attribute_record_list_size(nattr); ------------------ | Branch (271:28): [True: 1.83k, False: 320] ------------------ 272| 2.15k| igraph_int_t origlen = newlen - nv; 273| | 274| 2.15k| IGRAPH_ASSERT(origlen >= 0); ------------------ | | 924| 2.15k| do { \ | | 925| 2.15k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.15k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.15k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.15k] | | ------------------ ------------------ 275| | 276| | /* Find all the attributes that are newly added, and create new value vectors 277| | * for them in the original graph */ 278| 2.47k| for (igraph_int_t i = 0; i < nattrno; i++) { ------------------ | Branch (278:30): [True: 320, False: 2.15k] ------------------ 279| 320| const igraph_attribute_record_t *nattr_entry = igraph_attribute_record_list_get_ptr(nattr, i); 280| 320| const char *nname = nattr_entry->name; 281| 320| IGRAPH_CHECK(igraph_i_cattribute_find_or_create(val, nname, nattr_entry->type, origlen, NULL)); ------------------ | | 656| 320| do { \ | | 657| 320| igraph_error_t igraph_i_ret = (expr); \ | | 658| 320| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 320| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 320] | | ------------------ ------------------ 282| 320| } 283| | 284| | /* Now append the new values */ 285| 2.15k| length = igraph_attribute_record_list_size(val); 286| 2.33k| for (igraph_int_t i = 0; i < length; i++) { ------------------ | Branch (286:30): [True: 320, False: 2.01k] ------------------ 287| 320| igraph_attribute_record_t *oldrec = igraph_attribute_record_list_get_ptr(val, i); 288| 320| const igraph_attribute_record_t *newrec = nattr ------------------ | Branch (288:51): [True: 320, False: 0] ------------------ 289| 320| ? igraph_i_cattribute_find_const(nattr, oldrec->name, oldrec->type) 290| 320| : NULL; 291| | 292| 320| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == origlen); ------------------ | | 924| 320| do { \ | | 925| 320| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 320| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 320] | | ------------------ ------------------ 293| | 294| 320| if (newrec) { ------------------ | Branch (294:13): [True: 320, False: 0] ------------------ 295| | /* This attribute is present in nattr */ 296| 320| switch (oldrec->type) { 297| 148| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (297:13): [True: 148, False: 172] ------------------ 298| 148| if (nv != igraph_vector_size(newrec->value.as_vector)) { ------------------ | Branch (298:21): [True: 0, False: 148] ------------------ 299| 0| IGRAPH_ERROR("Invalid numeric attribute length.", IGRAPH_EINVAL); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 300| 0| } 301| 148| IGRAPH_CHECK(igraph_vector_append( ------------------ | | 656| 148| do { \ | | 657| 148| igraph_error_t igraph_i_ret = (expr); \ | | 658| 148| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 148| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 148] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 148| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 148] | | ------------------ ------------------ 302| 148| oldrec->value.as_vector, newrec->value.as_vector 303| 148| )); 304| 148| break; 305| 172| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (305:13): [True: 172, False: 148] ------------------ 306| 172| if (nv != igraph_strvector_size(newrec->value.as_strvector)) { ------------------ | Branch (306:21): [True: 137, False: 35] ------------------ 307| 137| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL); ------------------ | | 426| 137| do { \ | | 427| 137| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 137| return igraph_errno ; \ | | 429| 137| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 308| 137| } 309| 35| IGRAPH_CHECK(igraph_strvector_append( ------------------ | | 656| 35| do { \ | | 657| 35| igraph_error_t igraph_i_ret = (expr); \ | | 658| 35| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 35| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 35] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 35| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 35] | | ------------------ ------------------ 310| 35| oldrec->value.as_strvector, newrec->value.as_strvector 311| 35| )); 312| 35| break; 313| 35| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (313:13): [True: 0, False: 320] ------------------ 314| 0| if (nv != igraph_vector_bool_size(newrec->value.as_vector_bool)) { ------------------ | Branch (314:21): [True: 0, False: 0] ------------------ 315| 0| IGRAPH_ERROR("Invalid boolean attribute length.", IGRAPH_EINVAL); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 316| 0| } 317| 0| IGRAPH_CHECK(igraph_vector_bool_append( ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 318| 0| oldrec->value.as_vector_bool, newrec->value.as_vector_bool 319| 0| )); 320| 0| break; 321| 0| default: ------------------ | Branch (321:13): [True: 0, False: 320] ------------------ 322| 0| IGRAPH_WARNINGF( ------------------ | | 777| 0| do { \ | | 778| 0| igraph_warningf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 779| 0| __VA_ARGS__); \ | | 780| 0| } while (0) | | ------------------ | | | Branch (780:14): [Folded, False: 0] | | ------------------ ------------------ 323| 0| "Attribute '%s' with unknown type %d ignored", 324| 0| oldrec->name, (int) oldrec->type 325| 0| ); 326| 0| break; 327| 320| } 328| 320| } else { 329| | /* No such attribute among the new ones so just extend the length 330| | * of the current record */ 331| 0| IGRAPH_CHECK(igraph_attribute_record_resize(oldrec, newlen)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 332| 0| } 333| | 334| 183| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == newlen); ------------------ | | 924| 183| do { \ | | 925| 183| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 183| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 183] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 183| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 183] | | ------------------ ------------------ 335| 183| } 336| | 337| 2.01k| return IGRAPH_SUCCESS; 338| 2.15k|} cattributes.c:igraph_i_cattribute_find_const: 90| 320|) { 91| 320| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name); 92| 320| const igraph_attribute_record_t *rec; 93| | 94| 320| if (index >= 0) { ------------------ | Branch (94:9): [True: 320, False: 0] ------------------ 95| 320| rec = igraph_attribute_record_list_get_ptr(attrs, index); 96| 320| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) { ------------------ | Branch (96:13): [True: 0, False: 320] | Branch (96:53): [True: 320, False: 0] ------------------ 97| 320| return rec; 98| 320| } 99| 320| } 100| | 101| 0| return NULL; 102| 320|} cattributes.c:igraph_i_cattribute_revert_attribute_vector_sizes: 179| 137| igraph_attribute_record_list_t *attrlist, igraph_int_t origlen) { 180| | 181| 137| igraph_int_t no_of_attrs = igraph_attribute_record_list_size(attrlist); 182| 274| for (igraph_int_t i = 0; i < no_of_attrs; i++) { ------------------ | Branch (182:30): [True: 137, False: 137] ------------------ 183| 137| igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrlist, i); 184| 137| IGRAPH_ASSERT(igraph_attribute_record_size(rec) >= origlen); ------------------ | | 924| 137| do { \ | | 925| 137| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 137| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 137] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 137| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 137] | | ------------------ ------------------ 185| 137| if (igraph_attribute_record_resize(rec, origlen) != IGRAPH_SUCCESS) { ------------------ | Branch (185:13): [True: 0, False: 137] ------------------ 186| | /* We should have succeeded for known attribute types because we 187| | * always shrink the vector so throw a fatal error if this happens */ 188| 0| IGRAPH_FATAL("Unknown attribute type encountered."); ------------------ | | 895| 0| do { \ | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 897| 0| } while (0) | | ------------------ | | | Branch (897:14): [Folded, False: 0] | | ------------------ ------------------ 189| 0| } 190| 137| } 191| 137|} cattributes.c:igraph_i_cattribute_add_edges: 1463| 498|) { 1464| 498| igraph_int_t ne = igraph_vector_int_size(edges) / 2; 1465| 498| igraph_i_cattributes_t *attr = graph->attr; 1466| 498| return igraph_i_cattribute_add_vertices_or_edges(&attr->eal, igraph_ecount(graph), ne, nattr); 1467| 498|} cattributes.c:igraph_i_cattribute_find: 69| 320|) { 70| 320| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name); 71| 320| igraph_attribute_record_t *rec; 72| | 73| 320| if (index >= 0) { ------------------ | Branch (73:9): [True: 0, False: 320] ------------------ 74| 0| rec = igraph_attribute_record_list_get_ptr(attrs, index); 75| 0| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) { ------------------ | Branch (75:13): [True: 0, False: 0] | Branch (75:53): [True: 0, False: 0] ------------------ 76| 0| return rec; 77| 0| } 78| 0| } 79| | 80| 320| return NULL; 81| 320|} cattributes.c:igraph_i_cattribute_find_or_create: 147| 320|) { 148| 320| igraph_attribute_record_t *rec; 149| | 150| 320| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED); 151| 320| if (rec) { ------------------ | Branch (151:9): [True: 0, False: 320] ------------------ 152| 0| if (type != IGRAPH_ATTRIBUTE_UNSPECIFIED) { ------------------ | Branch (152:13): [True: 0, False: 0] ------------------ 153| 0| IGRAPH_CHECK(igraph_attribute_record_check_type(rec, type)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 154| 0| } 155| 320| } else { 156| 320| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(attrs, &rec)); ------------------ | | 656| 320| do { \ | | 657| 320| igraph_error_t igraph_i_ret = (expr); \ | | 658| 320| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 320| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 320] | | ------------------ ------------------ 157| 320| IGRAPH_CHECK(igraph_attribute_record_set_name(rec, name)); ------------------ | | 656| 320| do { \ | | 657| 320| igraph_error_t igraph_i_ret = (expr); \ | | 658| 320| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 320| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 320] | | ------------------ ------------------ 158| 320| IGRAPH_CHECK(igraph_attribute_record_set_type(rec, type)); ------------------ | | 656| 320| do { \ | | 657| 320| igraph_error_t igraph_i_ret = (expr); \ | | 658| 320| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 320| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 320] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 320| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 320] | | ------------------ ------------------ 159| 320| } 160| | 161| 320| if (length > 0 && igraph_attribute_record_size(rec) < length) { ------------------ | Branch (161:9): [True: 0, False: 320] | Branch (161:23): [True: 0, False: 0] ------------------ 162| 0| IGRAPH_CHECK(igraph_attribute_record_resize(rec, length)); ------------------ | | 656| 0| do { \ | | 657| 0| igraph_error_t igraph_i_ret = (expr); \ | | 658| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 0| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 0] | | ------------------ ------------------ 163| 0| } 164| | 165| 320| if (ptr) { ------------------ | Branch (165:9): [True: 0, False: 320] ------------------ 166| 0| *ptr = rec; 167| 0| } 168| | 169| 320| return IGRAPH_SUCCESS; 170| 320|} cattributes.c:igraph_i_cattribute_find_index: 49| 640|) { 50| 640| igraph_int_t n = igraph_attribute_record_list_size(attrs); 51| 640| for (igraph_int_t i = 0; i < n; i++) { ------------------ | Branch (51:30): [True: 320, False: 320] ------------------ 52| 320| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrs, i); 53| 320| if (!strcmp(rec->name, name)) { ------------------ | Branch (53:13): [True: 320, False: 0] ------------------ 54| 320| return i; 55| 320| } 56| 320| } 57| 320| return -1; 58| 640|} igraph_empty: 64| 827|igraph_error_t igraph_empty(igraph_t *graph, igraph_int_t n, igraph_bool_t directed) { 65| 827| return igraph_empty_attrs(graph, n, directed, 0); 66| 827|} igraph_empty_attrs: 102| 827|) { 103| | 104| 827| if (n < 0) { ------------------ | Branch (104:9): [True: 0, False: 827] ------------------ 105| 0| IGRAPH_ERROR("Number of vertices must not be negative.", IGRAPH_EINVAL); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 106| 0| } 107| | 108| 827| memset(graph, 0, sizeof(igraph_t)); 109| | 110| 827| graph->n = 0; 111| 827| graph->directed = directed; 112| 827| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0); ------------------ | | 119| 827| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 827| do { \ | | | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 827] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 827| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | 120| 827| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 827| do { \ | | | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 827| * incorrect destructor function with the pointer */ \ | | | | 607| 827| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 827] | | | | ------------------ | | | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 827| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 827] | | ------------------ ------------------ 113| 827| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0); ------------------ | | 119| 827| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 827| do { \ | | | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 827] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 827| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | 120| 827| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 827| do { \ | | | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 827| * incorrect destructor function with the pointer */ \ | | | | 607| 827| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 827] | | | | ------------------ | | | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 827| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 827] | | ------------------ ------------------ 114| 827| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0); ------------------ | | 119| 827| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 827| do { \ | | | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 827] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 827| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | 120| 827| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 827| do { \ | | | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 827| * incorrect destructor function with the pointer */ \ | | | | 607| 827| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 827] | | | | ------------------ | | | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 827| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 827] | | ------------------ ------------------ 115| 827| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0); ------------------ | | 119| 827| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 827| do { \ | | | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 827] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 827| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | 120| 827| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 827| do { \ | | | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 827| * incorrect destructor function with the pointer */ \ | | | | 607| 827| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 827] | | | | ------------------ | | | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 827| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 827] | | ------------------ ------------------ 116| 827| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1); ------------------ | | 119| 827| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 827| do { \ | | | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 827] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 827| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | 120| 827| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 827| do { \ | | | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 827| * incorrect destructor function with the pointer */ \ | | | | 607| 827| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 827] | | | | ------------------ | | | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 827| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 827] | | ------------------ ------------------ 117| 827| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1); ------------------ | | 119| 827| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 827| do { \ | | | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 827] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 827| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | 120| 827| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 827| do { \ | | | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 827| * incorrect destructor function with the pointer */ \ | | | | 607| 827| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 827] | | | | ------------------ | | | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 827| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 827] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 827] | | ------------------ ------------------ 118| | 119| | /* init cache */ 120| 827| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 33| 827|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 1.65k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 827, Folded] | | | | ------------------ | | ------------------ ------------------ 121| 827| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph."); ------------------ | | 709| 827| do { \ | | 710| 827| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 827| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 827] | | ------------------ ------------------ 122| 827| IGRAPH_FINALLY(igraph_free, graph->cache); ------------------ | | 603| 827| do { \ | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 827| * incorrect destructor function with the pointer */ \ | | 607| 827| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 827] | | ------------------ | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 827| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 827] | | ------------------ ------------------ 123| 827| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 124| 827| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache); ------------------ | | 603| 827| do { \ | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 827| * incorrect destructor function with the pointer */ \ | | 607| 827| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 827] | | ------------------ | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 827| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 827] | | ------------------ ------------------ 125| | 126| 827| VECTOR(graph->os)[0] = 0; ------------------ | | 60| 827|#define VECTOR(v) ((v).stor_begin) ------------------ 127| 827| VECTOR(graph->is)[0] = 0; ------------------ | | 60| 827|#define VECTOR(v) ((v).stor_begin) ------------------ 128| | 129| | /* init attributes */ 130| 827| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 131| | 132| | /* add the vertices */ 133| 827| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 134| | 135| 827| IGRAPH_FINALLY_CLEAN(8); 136| 827| return IGRAPH_SUCCESS; 137| 827|} igraph_destroy: 155| 827|void igraph_destroy(igraph_t *graph) { 156| 827| igraph_i_attribute_destroy(graph); 157| | 158| 827| igraph_i_property_cache_destroy(graph->cache); 159| 827| IGRAPH_FREE(graph->cache); ------------------ | | 36| 827|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 160| | 161| 827| igraph_vector_int_destroy(&graph->from); 162| 827| igraph_vector_int_destroy(&graph->to); 163| 827| igraph_vector_int_destroy(&graph->oi); 164| 827| igraph_vector_int_destroy(&graph->ii); 165| 827| igraph_vector_int_destroy(&graph->os); 166| 827| igraph_vector_int_destroy(&graph->is); 167| 827|} igraph_add_edges: 257| 690|) { 258| 690| igraph_int_t no_of_edges = igraph_vector_int_size(&graph->from); 259| 690| igraph_int_t edges_to_add = igraph_vector_int_size(edges) / 2; 260| 690| igraph_int_t new_no_of_edges; 261| 690| igraph_int_t i = 0; 262| 690| igraph_vector_int_t newoi, newii; 263| 690| igraph_bool_t directed = igraph_is_directed(graph); 264| | 265| 690| if (igraph_vector_int_size(edges) % 2 != 0) { ------------------ | Branch (265:9): [True: 0, False: 690] ------------------ 266| 0| IGRAPH_ERROR("Invalid (odd) length of edges vector.", IGRAPH_EINVAL); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 267| 0| } 268| 690| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) { ------------------ | Branch (268:9): [True: 192, False: 498] ------------------ 269| 192| IGRAPH_ERROR("Out-of-range vertex IDs when adding edges.", IGRAPH_EINVVID); ------------------ | | 426| 192| do { \ | | 427| 192| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 192| return igraph_errno ; \ | | 429| 192| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 270| 192| } 271| | 272| | /* from & to */ 273| 498| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges); ------------------ | | 47| 498| do { \ | | 48| 498| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 498| igraph_int_t _safe_sum; \ | | 50| 498| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 498] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 464| 0| do { \ | | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 467| 0| return igraph_errno; \ | | | | 468| 0| } while (0) | | | | ------------------ | | | | | Branch (468:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 498| *(res) = _safe_sum; \ | | 54| 498| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 498] | | ------------------ ------------------ 274| 498| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) { ------------------ | | 118| 498|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2) | | ------------------ | | | | 72| 498|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (274:9): [True: 0, False: 498] ------------------ 275| 0| IGRAPH_ERRORF("Maximum edge count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 464| 0| do { \ | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | 467| 0| return igraph_errno; \ | | 468| 0| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 276| 0| IGRAPH_ECOUNT_MAX); 277| 0| } 278| 498| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add)); ------------------ | | 656| 498| do { \ | | 657| 498| igraph_error_t igraph_i_ret = (expr); \ | | 658| 498| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 498| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 498] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 498| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 498] | | ------------------ ------------------ 279| 498| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add)); ------------------ | | 656| 498| do { \ | | 657| 498| igraph_error_t igraph_i_ret = (expr); \ | | 658| 498| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 498| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 498] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 498| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 498] | | ------------------ ------------------ 280| | 281| 3.47M| while (i < edges_to_add * 2) { ------------------ | Branch (281:12): [True: 3.47M, False: 498] ------------------ 282| 3.47M| if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 60| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 60| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (282:13): [True: 3.47M, False: 0] | Branch (282:25): [True: 0, False: 0] ------------------ 283| 3.47M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 60| 3.47M|#define VECTOR(v) ((v).stor_begin) ------------------ 284| 3.47M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 60| 3.47M|#define VECTOR(v) ((v).stor_begin) ------------------ 285| 3.47M| } else { 286| 0| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 60| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 287| 0| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 60| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 288| 0| } 289| 3.47M| } 290| | 291| | /* If an error occurs while the edges are being added, we make the necessary fixup 292| | * to ensure that the graph is still in a consistent state when this function returns. 293| | * The graph may already be on the finally stack when calling this function. We use 294| | * a separate finally stack level to avoid its destructor from being called on error, 295| | * so that the fixup can succeed. 296| | */ 297| | 298| 498|#define CHECK_ERR(expr) \ 299| 498| do { \ 300| 498| igraph_error_t err = (expr); \ 301| 498| if (err != IGRAPH_SUCCESS) { \ 302| 498| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ 303| 498| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ 304| 498| IGRAPH_FINALLY_EXIT(); \ 305| 498| IGRAPH_ERROR("Cannot add edges.", err); \ 306| 498| } \ 307| 498| } while (0) 308| | 309| | /* oi & ii */ 310| 498| IGRAPH_FINALLY_ENTER(); 311| 498| { 312| 498| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges)); ------------------ | | 299| 498| do { \ | | 300| 498| igraph_error_t err = (expr); \ | | 301| 498| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 498] | | ------------------ | | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 304| 0| IGRAPH_FINALLY_EXIT(); \ | | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 306| 0| } \ | | 307| 498| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 498] | | ------------------ ------------------ 313| 498| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi); ------------------ | | 603| 498| do { \ | | 604| 498| /* the following branch makes the compiler check the compatibility of \ | | 605| 498| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 498| * incorrect destructor function with the pointer */ \ | | 607| 498| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 498] | | ------------------ | | 608| 498| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 498| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 498] | | ------------------ ------------------ 314| 498| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges)); ------------------ | | 299| 498| do { \ | | 300| 498| igraph_error_t err = (expr); \ | | 301| 498| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 498] | | ------------------ | | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 304| 0| IGRAPH_FINALLY_EXIT(); \ | | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 306| 0| } \ | | 307| 498| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 498] | | ------------------ ------------------ 315| 498| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii); ------------------ | | 603| 498| do { \ | | 604| 498| /* the following branch makes the compiler check the compatibility of \ | | 605| 498| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 498| * incorrect destructor function with the pointer */ \ | | 607| 498| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 498] | | ------------------ | | 608| 498| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 498| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 498] | | ------------------ ------------------ 316| 498| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n)); ------------------ | | 299| 498| do { \ | | 300| 498| igraph_error_t err = (expr); \ | | 301| 498| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 498] | | ------------------ | | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 304| 0| IGRAPH_FINALLY_EXIT(); \ | | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 306| 0| } \ | | 307| 498| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 498] | | ------------------ ------------------ 317| 498| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n)); ------------------ | | 299| 498| do { \ | | 300| 498| igraph_error_t err = (expr); \ | | 301| 498| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 498] | | ------------------ | | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 304| 0| IGRAPH_FINALLY_EXIT(); \ | | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 306| 0| } \ | | 307| 498| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 498] | | ------------------ ------------------ 318| | 319| | /* Attributes */ 320| 498| if (graph->attr) { ------------------ | Branch (320:13): [True: 498, False: 0] ------------------ 321| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */ 322| 498| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr)); ------------------ | | 299| 498| do { \ | | 300| 498| igraph_error_t err = (expr); \ | | 301| 498| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 498] | | ------------------ | | 302| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 303| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 304| 0| IGRAPH_FINALLY_EXIT(); \ | | 305| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 306| 0| } \ | | 307| 498| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 498] | | ------------------ ------------------ 323| 498| } 324| | 325| | /* os & is, its length does not change, error safe */ 326| 498| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n); 327| 498| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n); 328| | 329| | /* everything went fine */ 330| 498| igraph_vector_int_destroy(&graph->oi); 331| 498| igraph_vector_int_destroy(&graph->ii); 332| 498| IGRAPH_FINALLY_CLEAN(2); 333| | 334| 498| graph->oi = newoi; 335| 498| graph->ii = newii; 336| 498| } 337| 0| IGRAPH_FINALLY_EXIT(); 338| | 339| 498|#undef CHECK_ERR 340| | 341| | /* modification successful, clear the cached properties of the graph. 342| | * 343| | * Adding one or more edges cannot make a strongly or weakly connected 344| | * graph disconnected, so we keep those flags if they are cached as true. 345| | * 346| | * Adding one or more edges may turn a DAG into a non-DAG or a forest into 347| | * a non-forest, so we can keep those flags only if they are cached as 348| | * false. 349| | * 350| | * Also, adding one or more edges does not change HAS_LOOP, HAS_MULTI and 351| | * HAS_MUTUAL if they were already true. 352| | */ 353| 498| igraph_i_property_cache_invalidate_conditionally( 354| 498| graph, 355| 498| /* keep_always = */ 0, 356| | /* keep_when_false = */ 357| 498| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST), 358| | /* keep_when_true = */ 359| 498| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) | 360| 498| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 361| 498| (1 << IGRAPH_PROP_HAS_LOOP) | 362| 498| (1 << IGRAPH_PROP_HAS_MULTI) | 363| 498| (1 << IGRAPH_PROP_HAS_MUTUAL) 364| 498| ); 365| | 366| 498| return IGRAPH_SUCCESS; 367| 498|} igraph_add_vertices: 391| 1.65k|) { 392| 1.65k| igraph_int_t ec = igraph_ecount(graph); 393| 1.65k| igraph_int_t vc = igraph_vcount(graph); 394| 1.65k| igraph_int_t new_vc; 395| 1.65k| igraph_int_t i; 396| | 397| 1.65k| if (nv < 0) { ------------------ | Branch (397:9): [True: 0, False: 1.65k] ------------------ 398| 0| IGRAPH_ERROR("Cannot add negative number of vertices.", IGRAPH_EINVAL); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 399| 0| } 400| | 401| 1.65k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc); ------------------ | | 47| 1.65k| do { \ | | 48| 1.65k| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 1.65k| igraph_int_t _safe_sum; \ | | 50| 1.65k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 1.65k] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 464| 0| do { \ | | | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 467| 0| return igraph_errno; \ | | | | 468| 0| } while (0) | | | | ------------------ | | | | | Branch (468:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 1.65k| *(res) = _safe_sum; \ | | 54| 1.65k| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 1.65k] | | ------------------ ------------------ 402| 1.65k| if (new_vc > IGRAPH_VCOUNT_MAX) { ------------------ | | 100| 1.65k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1) | | ------------------ | | | | 72| 1.65k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (402:9): [True: 0, False: 1.65k] ------------------ 403| 0| IGRAPH_ERRORF("Maximum vertex count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 464| 0| do { \ | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | 467| 0| return igraph_errno; \ | | 468| 0| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 404| 0| IGRAPH_VCOUNT_MAX); 405| 0| } 406| 1.65k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1)); ------------------ | | 656| 1.65k| do { \ | | 657| 1.65k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.65k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.65k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.65k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 1.65k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.65k] | | ------------------ ------------------ 407| 1.65k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1)); ------------------ | | 656| 1.65k| do { \ | | 657| 1.65k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.65k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.65k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.65k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 1.65k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.65k] | | ------------------ ------------------ 408| | 409| 1.65k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */ 410| 1.65k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */ 411| 112M| for (i = graph->n + 1; i < new_vc + 1; i++) { ------------------ | Branch (411:28): [True: 112M, False: 1.65k] ------------------ 412| 112M| VECTOR(graph->os)[i] = ec; ------------------ | | 60| 112M|#define VECTOR(v) ((v).stor_begin) ------------------ 413| 112M| VECTOR(graph->is)[i] = ec; ------------------ | | 60| 112M|#define VECTOR(v) ((v).stor_begin) ------------------ 414| 112M| } 415| | 416| 1.65k| graph->n += nv; 417| | 418| | /* Add attributes if necessary. This section is protected with 419| | * FINALLY_ENTER/EXIT so that the graph would not be accidentally 420| | * free upon error until it could be restored to a consistent state. */ 421| | 422| 1.65k| if (graph->attr) { ------------------ | Branch (422:9): [True: 1.65k, False: 0] ------------------ 423| 1.65k| igraph_error_t err; 424| 1.65k| IGRAPH_FINALLY_ENTER(); 425| 1.65k| err = igraph_i_attribute_add_vertices(graph, nv, attr); 426| 1.65k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (426:13): [True: 137, False: 1.51k] ------------------ 427| | /* Restore original vertex count on failure */ 428| 137| graph->n = vc; 429| 137| igraph_vector_int_resize(&graph->os, vc + 1); /* shrinks */ 430| 137| igraph_vector_int_resize(&graph->is, vc + 1); /* shrinks */ 431| 137| } 432| 1.65k| IGRAPH_FINALLY_EXIT(); 433| 1.65k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (433:13): [True: 137, False: 1.51k] ------------------ 434| 137| IGRAPH_ERROR("Cannot add vertices.", err); ------------------ | | 426| 137| do { \ | | 427| 137| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 137| return igraph_errno ; \ | | 429| 137| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 435| 137| } 436| 1.65k| } 437| | 438| | /* modification successful, clear the cached properties of the graph. 439| | * 440| | * Adding one or more nodes does not change the following cached properties: 441| | * 442| | * - IGRAPH_PROP_HAS_LOOP 443| | * - IGRAPH_PROP_HAS_MULTI 444| | * - IGRAPH_PROP_HAS_MUTUAL 445| | * - IGRAPH_PROP_IS_DAG (adding a node does not create/destroy cycles) 446| | * - IGRAPH_PROP_IS_FOREST (same) 447| | * 448| | * Adding one or more nodes without any edges incident on them is sure to 449| | * make the graph disconnected (weakly or strongly), so we can keep the 450| | * connectivity-related properties if they are currently cached as false. 451| | * (Actually, even if they weren't cached as false, we could still set them 452| | * to false, but we don't have that functionality yet). The only exception 453| | * is when the graph had zero vertices and gained only one vertex, because 454| | * it then becomes connected. That's why we have the condition below in the 455| | * keep_when_false section. 456| | */ 457| 1.51k| igraph_i_property_cache_invalidate_conditionally( 458| 1.51k| graph, 459| | /* keep_always = */ 460| 1.51k| (1 << IGRAPH_PROP_HAS_LOOP) | 461| 1.51k| (1 << IGRAPH_PROP_HAS_MULTI) | 462| 1.51k| (1 << IGRAPH_PROP_HAS_MUTUAL) | 463| 1.51k| (1 << IGRAPH_PROP_IS_DAG) | 464| 1.51k| (1 << IGRAPH_PROP_IS_FOREST), 465| | /* keep_when_false = */ 466| 1.51k| igraph_vcount(graph) >= 2 ? ( ------------------ | Branch (466:9): [True: 635, False: 882] ------------------ 467| 635| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 468| 635| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) 469| 882| ) : 0, 470| | /* keep_when_true = */ 471| 1.51k| 0 472| 1.51k| ); 473| | 474| 1.51k| return IGRAPH_SUCCESS; 475| 1.65k|} igraph_vcount: 829| 5.51k|igraph_int_t igraph_vcount(const igraph_t *graph) { 830| 5.51k| return graph->n; 831| 5.51k|} igraph_ecount: 843| 2.15k|igraph_int_t igraph_ecount(const igraph_t *graph) { 844| 2.15k| return igraph_vector_int_size(&graph->from); 845| 2.15k|} igraph_is_directed: 1133| 690|igraph_bool_t igraph_is_directed(const igraph_t *graph) { 1134| 690| return graph->directed; 1135| 690|} type_indexededgelist.c:igraph_i_create_start_vectors: 1076| 996| igraph_vector_int_t *iindex, igraph_int_t nodes) { 1077| | 1078| 996|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) 1079| | 1080| 996| igraph_int_t no_of_nodes; 1081| 996| igraph_int_t no_of_edges; 1082| 996| igraph_int_t i, j, idx; 1083| | 1084| 996| no_of_nodes = nodes; 1085| 996| no_of_edges = igraph_vector_int_size(el); 1086| | 1087| | /* result */ 1088| | 1089| 996| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1)); ------------------ | | 656| 996| do { \ | | 657| 996| igraph_error_t igraph_i_ret = (expr); \ | | 658| 996| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 996| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 996] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 996| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 996] | | ------------------ ------------------ 1090| | 1091| | /* create the index */ 1092| | 1093| 996| if (no_of_edges == 0) { ------------------ | Branch (1093:9): [True: 296, False: 700] ------------------ 1094| | /* empty graph */ 1095| 296| igraph_vector_int_null(res); 1096| 700| } else { 1097| 700| idx = -1; 1098| 3.77M| for (i = 0; i <= EDGE(0); i++) { ------------------ | | 1078| 3.77M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 3.77M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 3.77M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (1098:21): [True: 3.77M, False: 700] ------------------ 1099| 3.77M| idx++; VECTOR(*res)[idx] = 0; ------------------ | | 60| 3.77M|#define VECTOR(v) ((v).stor_begin) ------------------ 1100| 3.77M| } 1101| 6.94M| for (i = 1; i < no_of_edges; i++) { ------------------ | Branch (1101:21): [True: 6.94M, False: 700] ------------------ 1102| 6.94M| igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1078| 6.94M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1078| 6.94M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.94M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1103| 11.2M| for (j = 0; j < n; j++) { ------------------ | Branch (1103:25): [True: 4.34M, False: 6.94M] ------------------ 1104| 4.34M| idx++; VECTOR(*res)[idx] = i; ------------------ | | 60| 4.34M|#define VECTOR(v) ((v).stor_begin) ------------------ 1105| 4.34M| } 1106| 6.94M| } 1107| 700| j = EDGE(VECTOR(*res)[idx]); ------------------ | | 1078| 700|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 700|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 700|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1108| 23.2M| for (i = 0; i < no_of_nodes - j; i++) { ------------------ | Branch (1108:21): [True: 23.2M, False: 700] ------------------ 1109| 23.2M| idx++; VECTOR(*res)[idx] = no_of_edges; ------------------ | | 60| 23.2M|#define VECTOR(v) ((v).stor_begin) ------------------ 1110| 23.2M| } 1111| 700| } 1112| | 1113| | /* clean */ 1114| | 1115| 996|# undef EDGE 1116| 996| return IGRAPH_SUCCESS; 1117| 996|} igraph_dl_yylex_destroy_wrapper: 37| 1.82k|void igraph_dl_yylex_destroy_wrapper (void *scanner ) { 38| 1.82k| (void) igraph_dl_yylex_destroy(scanner); 39| 1.82k|} igraph_read_graph_dl: 68| 2.32k| igraph_bool_t directed) { 69| | 70| 2.32k| igraph_int_t n, n2; 71| 2.32k| const igraph_strvector_t *namevec = 0; 72| 2.32k| igraph_attribute_record_list_t name, weight; 73| 2.32k| igraph_attribute_record_list_t *pname = NULL; 74| 2.32k| igraph_attribute_record_list_t *pweight = NULL; 75| 2.32k| igraph_attribute_record_t *namerec, *weightrec; 76| 2.32k| const char *namestr = "name", *weightstr = "weight"; 77| 2.32k| igraph_i_dl_parsedata_t context; 78| | 79| 2.32k| context.eof = 0; 80| 2.32k| context.mode = 0; 81| 2.32k| context.n = -1; 82| 2.32k| context.from = 0; 83| 2.32k| context.to = 0; 84| 2.32k| context.errmsg[0] = '\0'; 85| 2.32k| context.igraph_errno = IGRAPH_SUCCESS; 86| | 87| 2.32k| IGRAPH_VECTOR_INT_INIT_FINALLY(&context.edges, 0); ------------------ | | 119| 2.32k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 2.32k| do { \ | | | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | 120| 2.32k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 2.32k| do { \ | | | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.32k] | | | | ------------------ | | | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 2.32k] | | ------------------ ------------------ 88| 2.32k| IGRAPH_VECTOR_INIT_FINALLY(&context.weights, 0); ------------------ | | 104| 2.32k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 656| 2.32k| do { \ | | | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | 105| 2.32k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 603| 2.32k| do { \ | | | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.32k] | | | | ------------------ | | | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | | Branch (105:60): [Folded, False: 2.32k] | | ------------------ ------------------ 89| 2.32k| IGRAPH_CHECK(igraph_strvector_init(&context.labels, 0)); ------------------ | | 656| 2.32k| do { \ | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 2.32k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.32k] | | ------------------ ------------------ 90| 2.32k| IGRAPH_FINALLY(igraph_strvector_destroy, &context.labels); ------------------ | | 603| 2.32k| do { \ | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | 607| 2.32k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.32k] | | ------------------ | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.32k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.32k] | | ------------------ ------------------ 91| 2.32k| IGRAPH_TRIE_INIT_FINALLY(&context.trie, /*names=*/ 1); ------------------ | | 55| 2.32k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \ | | ------------------ | | | | 656| 2.32k| do { \ | | | | 657| 2.32k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.32k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.32k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.32k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | 56| 2.32k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0) | | ------------------ | | | | 603| 2.32k| do { \ | | | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.32k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.32k] | | | | ------------------ | | | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.32k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.32k] | | | | ------------------ | | ------------------ | | | Branch (56:59): [Folded, False: 2.32k] | | ------------------ ------------------ 92| | 93| 2.32k| igraph_dl_yylex_init_extra(&context, &context.scanner); 94| 2.32k| IGRAPH_FINALLY(igraph_dl_yylex_destroy_wrapper, context.scanner); ------------------ | | 603| 2.32k| do { \ | | 604| 2.32k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.32k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.32k| * incorrect destructor function with the pointer */ \ | | 607| 2.32k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.32k] | | ------------------ | | 608| 2.32k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.32k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.32k] | | ------------------ ------------------ 95| | 96| 2.32k| igraph_dl_yyset_in(instream, context.scanner); 97| | 98| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */ 99| 2.32k| IGRAPH_FINALLY_ENTER(); 100| 2.32k| int err = igraph_dl_yyparse(&context); 101| 2.32k| IGRAPH_FINALLY_EXIT(); 102| 2.32k| switch (err) { 103| 827| case 0: /* success */ ------------------ | Branch (103:5): [True: 827, False: 1.49k] ------------------ 104| 827| break; 105| 1.49k| case 1: /* parse error */ ------------------ | Branch (105:5): [True: 1.49k, False: 827] ------------------ 106| 1.49k| if (context.errmsg[0] != 0) { ------------------ | Branch (106:13): [True: 1.44k, False: 53] ------------------ 107| 1.44k| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR); ------------------ | | 426| 1.44k| do { \ | | 427| 1.44k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 1.44k| return igraph_errno ; \ | | 429| 1.44k| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 108| 1.44k| } else if (context.igraph_errno != IGRAPH_SUCCESS) { ------------------ | Branch (108:20): [True: 53, False: 0] ------------------ 109| 53| IGRAPH_ERROR("", context.igraph_errno); ------------------ | | 426| 53| do { \ | | 427| 53| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 53| return igraph_errno ; \ | | 429| 53| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 110| 53| } else { 111| 0| IGRAPH_ERROR("Cannot read DL file.", IGRAPH_PARSEERROR); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 112| 0| } 113| 0| break; 114| 0| case 2: /* out of memory */ ------------------ | Branch (114:5): [True: 0, False: 2.32k] ------------------ 115| 0| IGRAPH_ERROR("Cannot read DL file.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 116| 0| break; 117| 0| default: /* must never reach here */ ------------------ | Branch (117:5): [True: 0, False: 2.32k] ------------------ 118| | /* Hint: This will usually be triggered if an IGRAPH_CHECK() is used in a Bison 119| | * action instead of an IGRAPH_YY_CHECK(), resulting in an igraph errno being 120| | * returned in place of a Bison error code. 121| | * TODO: What if future Bison versions introduce error codes other than 0, 1 and 2? 122| | */ 123| 0| IGRAPH_FATALF("Parser returned unexpected error code (%d) when reading DL file.", err); ------------------ | | 875| 0| do { \ | | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 877| 0| __VA_ARGS__); \ | | 878| 0| } while (0) | | ------------------ | | | Branch (878:14): [Folded, False: 0] | | ------------------ ------------------ 124| 2.32k| } 125| | 126| | /* Extend the weight vector, if needed */ 127| 827| n = igraph_vector_size(&context.weights); 128| 827| n2 = igraph_vector_int_size(&context.edges) / 2; 129| 827| if (n != 0) { ------------------ | Branch (129:9): [True: 262, False: 565] ------------------ 130| 262| IGRAPH_CHECK(igraph_vector_resize(&context.weights, n2)); ------------------ | | 656| 262| do { \ | | 657| 262| igraph_error_t igraph_i_ret = (expr); \ | | 658| 262| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 262| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 262] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 262| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 262] | | ------------------ ------------------ 131| 9.74k| for (; n < n2; n++) { ------------------ | Branch (131:16): [True: 9.47k, False: 262] ------------------ 132| 9.47k| VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 60| 9.47k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 138| 9.47k|#define IGRAPH_NAN ((double)NAN) ------------------ 133| 9.47k| } 134| 262| } 135| | 136| | /* Check number of vertices */ 137| 827| if (n2 > 0) { ------------------ | Branch (137:9): [True: 599, False: 228] ------------------ 138| 599| n = igraph_vector_int_max(&context.edges); 139| 599| } else { 140| 228| n = 0; 141| 228| } 142| 827| if (n >= context.n) { ------------------ | Branch (142:9): [True: 304, False: 523] ------------------ 143| 304| IGRAPH_WARNING("More vertices than specified in `DL' file"); ------------------ | | 797| 304| do { \ | | 798| 304| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 799| 304| } while (0) | | ------------------ | | | Branch (799:14): [Folded, False: 304] | | ------------------ ------------------ 144| 304| context.n = n; 145| 304| } 146| | 147| | /* Prepare attributes */ 148| | 149| | /* Labels */ 150| 827| if (igraph_strvector_size(&context.labels) != 0) { ------------------ | Branch (150:9): [True: 96, False: 731] ------------------ 151| 96| namevec = (const igraph_strvector_t*) &context.labels; 152| 731| } else if (igraph_trie_size(&context.trie) != 0) { ------------------ | Branch (152:16): [True: 76, False: 655] ------------------ 153| 76| namevec = igraph_i_trie_borrow_keys(&context.trie); 154| 76| } 155| 827| if (namevec) { ------------------ | Branch (155:9): [True: 172, False: 655] ------------------ 156| 172| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1)); ------------------ | | 656| 172| do { \ | | 657| 172| igraph_error_t igraph_i_ret = (expr); \ | | 658| 172| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 172| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 172] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 172| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 172] | | ------------------ ------------------ 157| 172| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name); ------------------ | | 603| 172| do { \ | | 604| 172| /* the following branch makes the compiler check the compatibility of \ | | 605| 172| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 172| * incorrect destructor function with the pointer */ \ | | 607| 172| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 172] | | ------------------ | | 608| 172| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 172| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 172] | | ------------------ ------------------ 158| | 159| 172| namerec = igraph_attribute_record_list_get_ptr(&name, 0); 160| 172| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr)); ------------------ | | 656| 172| do { \ | | 657| 172| igraph_error_t igraph_i_ret = (expr); \ | | 658| 172| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 172| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 172] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 172| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 172] | | ------------------ ------------------ 161| 172| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING)); ------------------ | | 656| 172| do { \ | | 657| 172| igraph_error_t igraph_i_ret = (expr); \ | | 658| 172| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 172| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 172] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 172| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 172] | | ------------------ ------------------ 162| 172| IGRAPH_CHECK(igraph_strvector_update(namerec->value.as_strvector, namevec)); ------------------ | | 656| 172| do { \ | | 657| 172| igraph_error_t igraph_i_ret = (expr); \ | | 658| 172| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 172| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 172] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 172| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 172] | | ------------------ ------------------ 163| | 164| 172| pname = &name; 165| 172| } 166| | 167| | /* Weights */ 168| 827| if (igraph_vector_size(&context.weights) != 0) { ------------------ | Branch (168:9): [True: 262, False: 565] ------------------ 169| 262| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1)); ------------------ | | 656| 262| do { \ | | 657| 262| igraph_error_t igraph_i_ret = (expr); \ | | 658| 262| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 262| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 262] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 262| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 262] | | ------------------ ------------------ 170| 262| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight); ------------------ | | 603| 262| do { \ | | 604| 262| /* the following branch makes the compiler check the compatibility of \ | | 605| 262| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 262| * incorrect destructor function with the pointer */ \ | | 607| 262| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 262] | | ------------------ | | 608| 262| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 262| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 262] | | ------------------ ------------------ 171| | 172| 262| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0); 173| 262| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr)); ------------------ | | 656| 262| do { \ | | 657| 262| igraph_error_t igraph_i_ret = (expr); \ | | 658| 262| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 262| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 262] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 262| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 262] | | ------------------ ------------------ 174| 262| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC)); ------------------ | | 656| 262| do { \ | | 657| 262| igraph_error_t igraph_i_ret = (expr); \ | | 658| 262| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 262| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 262] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 262| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 262] | | ------------------ ------------------ 175| 262| igraph_vector_swap(weightrec->value.as_vector, &context.weights); 176| | 177| 262| pweight = &weight; 178| 262| } 179| | 180| | /* Create graph */ 181| 827| IGRAPH_CHECK(igraph_empty(graph, 0, directed)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 827] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 827] | | ------------------ ------------------ 182| 827| IGRAPH_FINALLY(igraph_destroy, graph); ------------------ | | 603| 827| do { \ | | 604| 827| /* the following branch makes the compiler check the compatibility of \ | | 605| 827| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 827| * incorrect destructor function with the pointer */ \ | | 607| 827| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 827] | | ------------------ | | 608| 827| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 827| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 827] | | ------------------ ------------------ 183| 827| IGRAPH_CHECK(igraph_add_vertices(graph, context.n, pname)); ------------------ | | 656| 827| do { \ | | 657| 827| igraph_error_t igraph_i_ret = (expr); \ | | 658| 827| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 827| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 137, False: 690] | | | | ------------------ | | ------------------ | | 659| 137| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 137| do { \ | | | | 427| 137| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 137| return igraph_errno ; \ | | | | 429| 137| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 137| } \ | | 661| 827| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 690] | | ------------------ ------------------ 184| 690| IGRAPH_CHECK(igraph_add_edges(graph, &context.edges, pweight)); ------------------ | | 656| 690| do { \ | | 657| 690| igraph_error_t igraph_i_ret = (expr); \ | | 658| 690| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 690| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 192, False: 498] | | | | ------------------ | | ------------------ | | 659| 192| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 192| do { \ | | | | 427| 192| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 192| return igraph_errno ; \ | | | | 429| 192| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 192| } \ | | 661| 690| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 498] | | ------------------ ------------------ 185| | 186| 498| if (pweight) { ------------------ | Branch (186:9): [True: 148, False: 350] ------------------ 187| 148| igraph_attribute_record_list_destroy(pweight); 188| 148| IGRAPH_FINALLY_CLEAN(1); 189| 148| } 190| | 191| 498| if (pname) { ------------------ | Branch (191:9): [True: 34, False: 464] ------------------ 192| 34| igraph_attribute_record_list_destroy(pname); 193| 34| IGRAPH_FINALLY_CLEAN(1); 194| 34| } 195| | 196| | /* don't destroy the graph itself but pop it from the finally stack */ 197| 498| IGRAPH_FINALLY_CLEAN(1); 198| | 199| 498| igraph_trie_destroy(&context.trie); 200| 498| igraph_strvector_destroy(&context.labels); 201| 498| igraph_vector_int_destroy(&context.edges); 202| 498| igraph_vector_destroy(&context.weights); 203| 498| igraph_dl_yylex_destroy(context.scanner); 204| 498| IGRAPH_FINALLY_CLEAN(5); 205| | 206| 498| return IGRAPH_SUCCESS; 207| 690|} igraph_i_parse_integer: 52| 6.18M|igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_int_t *value) { 53| 6.18M| char buffer[128]; 54| 6.18M| char *tmp, *end; 55| 6.18M| char last_char; 56| 6.18M| igraph_bool_t out_of_range, dynamic_alloc; 57| 6.18M| long long val; 58| | 59| 6.18M| if (length == 0) { ------------------ | Branch (59:9): [True: 0, False: 6.18M] ------------------ 60| 0| IGRAPH_ERROR("Cannot parse integer from empty string.", IGRAPH_PARSEERROR); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 61| 0| } 62| | 63| 6.18M| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 64| | 65| 6.18M| if (dynamic_alloc) { ------------------ | Branch (65:9): [True: 216, False: 6.18M] ------------------ 66| 216| tmp = IGRAPH_CALLOC(length+1, char); ------------------ | | 33| 216|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 432| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 216, False: 0] | | | | | Branch (31:24): [True: 216, False: 0] | | | | | Branch (31:66): [True: 216, False: 0] | | | | ------------------ | | ------------------ ------------------ 67| 216| IGRAPH_CHECK_OOM(tmp, "Failed to parse integer."); ------------------ | | 709| 216| do { \ | | 710| 216| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 216| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 216] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 216| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 216] | | ------------------ ------------------ 68| 6.18M| } else { 69| 6.18M| tmp = buffer; 70| 6.18M| } 71| | 72| 6.18M| strncpy(tmp, str, length); 73| 6.18M| tmp[length]='\0'; 74| | 75| | /* To avoid having to choose the appropriate strto?() function based on 76| | * the definition of igraph_int_t, we first use a long long variable 77| | * which should be at least as large as igraph_int_t on any platform. */ 78| 6.18M| errno = 0; 79| 6.18M| val = strtoll(tmp, &end, 10); 80| 6.18M| out_of_range = errno == ERANGE; 81| 6.18M| *value = (igraph_int_t) val; 82| 6.18M| last_char = *end; 83| 6.18M| if (*value != val) { ------------------ | Branch (83:9): [True: 0, False: 6.18M] ------------------ 84| 0| out_of_range = true; 85| 0| } 86| | 87| | /* Free memory before raising any errors. */ 88| 6.18M| if (dynamic_alloc) { ------------------ | Branch (88:9): [True: 216, False: 6.18M] ------------------ 89| 216| IGRAPH_FREE(tmp); ------------------ | | 36| 216|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 90| 216| } 91| | 92| 6.18M| if (out_of_range) { ------------------ | Branch (92:9): [True: 41, False: 6.18M] ------------------ 93| 41| IGRAPH_ERROR("Failed to parse integer.", val > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 426| 41| do { \ | | 427| 82| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (427:63): [True: 40, False: 1] | | ------------------ | | 428| 82| return igraph_errno ; \ | | ------------------ | | | Branch (428:16): [True: 40, False: 1] | | ------------------ | | 429| 41| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 94| 41| } 95| | 96| | /* Did we parse to the end of the string? */ 97| 6.18M| if (last_char) { ------------------ | Branch (97:9): [True: 2, False: 6.18M] ------------------ 98| 2| IGRAPH_ERRORF("Unexpected character '%c' while parsing integer.", IGRAPH_PARSEERROR, last_char); ------------------ | | 464| 2| do { \ | | 465| 2| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 2| igraph_errno, __VA_ARGS__) ; \ | | 467| 2| return igraph_errno; \ | | 468| 2| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 99| 2| } 100| | 101| 6.18M| return IGRAPH_SUCCESS; 102| 6.18M|} igraph_i_parse_real: 113| 34.6k|igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) { 114| 34.6k| char buffer[128]; 115| 34.6k| char *tmp, *end; 116| 34.6k| char last_char; 117| 34.6k| igraph_bool_t out_of_range, dynamic_alloc; 118| | 119| 34.6k| if (length == 0) { ------------------ | Branch (119:9): [True: 0, False: 34.6k] ------------------ 120| 0| IGRAPH_ERROR("Cannot parse real number from empty string.", IGRAPH_PARSEERROR); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 121| 0| } 122| | 123| 34.6k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 124| | 125| 34.6k| if (dynamic_alloc) { ------------------ | Branch (125:9): [True: 216, False: 34.4k] ------------------ 126| 216| tmp = IGRAPH_CALLOC(length+1, char); ------------------ | | 33| 216|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 432| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 216, False: 0] | | | | | Branch (31:24): [True: 216, False: 0] | | | | | Branch (31:66): [True: 216, False: 0] | | | | ------------------ | | ------------------ ------------------ 127| 216| IGRAPH_CHECK_OOM(tmp, "Failed to parse real number."); ------------------ | | 709| 216| do { \ | | 710| 216| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 216| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 216] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 216| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 216] | | ------------------ ------------------ 128| 34.4k| } else { 129| 34.4k| tmp = buffer; 130| 34.4k| } 131| | 132| 34.6k| strncpy(tmp, str, length); 133| 34.6k| tmp[length]='\0'; 134| | 135| 34.6k| errno = 0; 136| 34.6k| *value = strtod(tmp, &end); 137| 34.6k| out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */ 138| 34.6k| last_char = *end; 139| | 140| | /* Free memory before raising any errors. */ 141| 34.6k| if (dynamic_alloc) { ------------------ | Branch (141:9): [True: 216, False: 34.4k] ------------------ 142| 216| IGRAPH_FREE(tmp); ------------------ | | 36| 216|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 143| 216| } 144| | 145| 34.6k| if (out_of_range) { ------------------ | Branch (145:9): [True: 26, False: 34.6k] ------------------ 146| 26| IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 426| 26| do { \ | | 427| 52| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (427:63): [True: 17, False: 9] | | ------------------ | | 428| 52| return igraph_errno ; \ | | ------------------ | | | Branch (428:16): [True: 17, False: 9] | | ------------------ | | 429| 26| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 147| 26| } 148| | 149| | /* Did we parse to the end of the string? */ 150| 34.6k| if (last_char) { ------------------ | Branch (150:9): [True: 0, False: 34.6k] ------------------ 151| 0| IGRAPH_ERRORF("Unexpected character '%c' while parsing real number.", IGRAPH_PARSEERROR, last_char); ------------------ | | 464| 0| do { \ | | 465| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 0| igraph_errno, __VA_ARGS__) ; \ | | 467| 0| return igraph_errno; \ | | 468| 0| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 152| 0| } 153| | 154| 34.6k| return IGRAPH_SUCCESS; 155| 34.6k|}