igraph_dl_yylex: 1151| 10.6M|{ 1152| 10.6M| yy_state_type yy_current_state; 1153| 10.6M| char *yy_cp, *yy_bp; 1154| 10.6M| int yy_act; 1155| 10.6M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1156| | 1157| 10.6M| yylval = yylval_param; ------------------ | | 964| 10.6M| # define yylval yyg->yylval_r ------------------ 1158| | 1159| 10.6M| yylloc = yylloc_param; ------------------ | | 966| 10.6M| # define yylloc yyg->yylloc_r ------------------ 1160| | 1161| 10.6M| if ( !yyg->yy_init ) ------------------ | Branch (1161:7): [True: 2.33k, False: 10.6M] ------------------ 1162| 2.33k| { 1163| 2.33k| yyg->yy_init = 1; 1164| | 1165| |#ifdef YY_USER_INIT 1166| | YY_USER_INIT; 1167| |#endif 1168| | 1169| 2.33k| if ( ! yyg->yy_start ) ------------------ | Branch (1169:8): [True: 2.33k, False: 0] ------------------ 1170| 2.33k| yyg->yy_start = 1; /* first start state */ 1171| | 1172| 2.33k| if ( ! yyin ) ------------------ | | 356| 2.33k|#define yyin yyg->yyin_r ------------------ | Branch (1172:8): [True: 0, False: 2.33k] ------------------ 1173| 0| yyin = stdin; ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 1174| | 1175| 2.33k| if ( ! yyout ) ------------------ | | 357| 2.33k|#define yyout yyg->yyout_r ------------------ | Branch (1175:8): [True: 2.33k, False: 0] ------------------ 1176| 2.33k| yyout = stdout; ------------------ | | 357| 2.33k|#define yyout yyg->yyout_r ------------------ 1177| | 1178| 2.33k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 0, False: 2.33k] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ | Branch (1178:8): [True: 2.33k, False: 0] ------------------ 1179| 2.33k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 2.33k|#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack ------------------ 1180| 2.33k| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 527| 2.33k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1181| 2.33k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 2.33k|#define yy_create_buffer igraph_dl_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 2.33k|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 2.33k|#define YY_BUF_SIZE 16384 ------------------ 1182| 2.33k| } 1183| | 1184| 2.33k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.33k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1185| 2.33k| } 1186| | 1187| 10.6M| { 1188| 10.6M|#line 80 "/src/igraph/src/io/dl-lexer.l" 1189| | 1190| | 1191| 10.6M|#line 1192 "/src/igraph/build/src/io/parsers/dl-lexer.c" 1192| | 1193| 17.4M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1193:23): [True: 17.4M, Folded] ------------------ 1194| 17.4M| { 1195| 17.4M| yy_cp = yyg->yy_c_buf_p; 1196| | 1197| | /* Support of yytext. */ 1198| 17.4M| *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.4M| yy_bp = yy_cp; 1204| | 1205| 17.4M| yy_current_state = yyg->yy_start; 1206| 17.4M|yy_match: 1207| 17.4M| do 1208| 52.3M| { 1209| 52.3M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 52.3M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1210| 52.3M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1210:9): [True: 46.9M, False: 5.31M] ------------------ 1211| 46.9M| { 1212| 46.9M| yyg->yy_last_accepting_state = yy_current_state; 1213| 46.9M| yyg->yy_last_accepting_cpos = yy_cp; 1214| 46.9M| } 1215| 85.7M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1215:12): [True: 33.4M, False: 52.3M] ------------------ 1216| 33.4M| { 1217| 33.4M| yy_current_state = (int) yy_def[yy_current_state]; 1218| 33.4M| if ( yy_current_state >= 129 ) ------------------ | Branch (1218:10): [True: 18.6M, False: 14.8M] ------------------ 1219| 18.6M| yy_c = yy_meta[yy_c]; 1220| 33.4M| } 1221| 52.3M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1222| 52.3M| ++yy_cp; 1223| 52.3M| } 1224| 52.3M| while ( yy_base[yy_current_state] != 493 ); ------------------ | Branch (1224:11): [True: 34.8M, False: 17.4M] ------------------ 1225| | 1226| 17.4M|yy_find_action: 1227| 17.4M| yy_act = yy_accept[yy_current_state]; 1228| 17.4M| if ( yy_act == 0 ) ------------------ | Branch (1228:8): [True: 14.5M, False: 2.91M] ------------------ 1229| 14.5M| { /* have to back up */ 1230| 14.5M| yy_cp = yyg->yy_last_accepting_cpos; 1231| 14.5M| yy_current_state = yyg->yy_last_accepting_state; 1232| 14.5M| yy_act = yy_accept[yy_current_state]; 1233| 14.5M| } 1234| | 1235| 17.4M| YY_DO_BEFORE_ACTION; ------------------ | | 588| 17.4M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 577| 17.4M|#define yytext_ptr yytext_r | | ------------------ | | 589| 17.4M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 17.4M|#define yyleng yyg->yyleng_r | | ------------------ | | 590| 17.4M| yyg->yy_hold_char = *yy_cp; \ | | 591| 17.4M| *yy_cp = '\0'; \ | | 592| 17.4M| yyg->yy_c_buf_p = yy_cp; ------------------ 1236| | 1237| 17.4M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 594| 34.9M|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1237:8): [True: 17.4M, False: 11.7k] | Branch (1237:38): [True: 2.55M, False: 14.8M] ------------------ 1238| 2.55M| { 1239| 2.55M| int yyl; 1240| 5.11M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 359| 5.11M|#define yyleng yyg->yyleng_r ------------------ | Branch (1240:19): [True: 2.55M, False: 2.55M] ------------------ 1241| 2.55M| if ( yytext[yyl] == '\n' ) ------------------ | | 360| 2.55M|#define yytext yyg->yytext_r ------------------ | Branch (1241:10): [True: 2.55M, False: 1.22k] ------------------ 1242| | 1243| 2.55M| do{ yylineno++; ------------------ | | 361| 2.55M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 527| 2.55M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1244| 2.55M| yycolumn=0; ------------------ | | 362| 2.55M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 527| 2.55M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1245| 2.55M| }while(0) ------------------ | Branch (1245:12): [Folded, False: 2.55M] ------------------ 1246| 2.55M|; 1247| 2.55M| } 1248| | 1249| 17.4M|do_action: /* This label is used only to access EOF actions. */ 1250| | 1251| 17.4M| switch ( yy_act ) 1252| 17.4M| { /* beginning of action switch */ 1253| 0| case 0: /* must back up */ ------------------ | Branch (1253:4): [True: 0, False: 17.4M] ------------------ 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.55M|case 1: ------------------ | Branch (1260:1): [True: 2.55M, False: 14.9M] ------------------ 1261| |/* rule 1 can match eol */ 1262| 2.55M|YY_RULE_SETUP ------------------ | | 1146| 2.55M| YY_USER_ACTION | | ------------------ | | | | 890| 2.55M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.55M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.55M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.55M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1263| 2.55M|#line 82 "/src/igraph/src/io/dl-lexer.l" 1264| 2.55M|{ return NEWLINE; } 1265| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1266| 2.17k|case 2: ------------------ | Branch (1266:1): [True: 2.17k, False: 17.4M] ------------------ 1267| 2.17k|YY_RULE_SETUP ------------------ | | 1146| 2.17k| YY_USER_ACTION | | ------------------ | | | | 890| 2.17k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.17k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1268| 2.17k|#line 84 "/src/igraph/src/io/dl-lexer.l" 1269| 2.17k|{ return DL; } 1270| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1271| 2.16k|case 3: ------------------ | Branch (1271:1): [True: 2.16k, False: 17.4M] ------------------ 1272| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1273| 2.16k|#line 85 "/src/igraph/src/io/dl-lexer.l" 1274| 2.16k|{ return NEQ; } 1275| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1276| 2.18k|case 4: ------------------ | Branch (1276:1): [True: 2.18k, False: 17.4M] ------------------ 1277| 2.18k|YY_RULE_SETUP ------------------ | | 1146| 2.18k| YY_USER_ACTION | | ------------------ | | | | 890| 2.18k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.18k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.18k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.18k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1278| 2.18k|#line 86 "/src/igraph/src/io/dl-lexer.l" 1279| 2.18k|{ return NUM; } 1280| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1281| 2.00k|case 5: ------------------ | Branch (1281:1): [True: 2.00k, False: 17.4M] ------------------ 1282| 2.00k|YY_RULE_SETUP ------------------ | | 1146| 2.00k| YY_USER_ACTION | | ------------------ | | | | 890| 2.00k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.00k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.00k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.00k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1283| 2.00k|#line 88 "/src/igraph/src/io/dl-lexer.l" 1284| 2.00k|{ 1285| 2.00k| switch (yyextra->mode) { ------------------ | | 358| 2.00k|#define yyextra yyg->yyextra_r ------------------ | Branch (1285:11): [True: 2.00k, False: 0] ------------------ 1286| 493| case 0: BEGIN(FULLMATRIX); ------------------ | | 369| 493|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 0: BEGIN(FULLMATRIX); ------------------ | | 906| 493|#define FULLMATRIX 2 ------------------ | Branch (1286:3): [True: 493, False: 1.50k] ------------------ 1287| 493| break; 1288| 992| case 1: BEGIN(EDGELIST); ------------------ | | 369| 992|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 1: BEGIN(EDGELIST); ------------------ | | 907| 992|#define EDGELIST 3 ------------------ | Branch (1288:3): [True: 992, False: 1.00k] ------------------ 1289| 992| break; 1290| 515| case 2: BEGIN(NODELIST); ------------------ | | 369| 515|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 2: BEGIN(NODELIST); ------------------ | | 908| 515|#define NODELIST 4 ------------------ | Branch (1290:3): [True: 515, False: 1.48k] ------------------ 1291| 515| break; 1292| 2.00k| } 1293| 2.00k| return DATA; } 1294| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1295| 345|case 6: ------------------ | Branch (1295:1): [True: 345, False: 17.4M] ------------------ 1296| 345|YY_RULE_SETUP ------------------ | | 1146| 345| YY_USER_ACTION | | ------------------ | | | | 890| 345|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 345| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 345|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 345|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1297| 345|#line 99 "/src/igraph/src/io/dl-lexer.l" 1298| 345|{ BEGIN(LABELM); return LABELS; } ------------------ | | 369| 345|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(LABELM); return LABELS; } ------------------ | | 905| 345|#define LABELM 1 ------------------ 1299| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1300| 384|case 7: ------------------ | Branch (1300:1): [True: 384, False: 17.4M] ------------------ 1301| 384|YY_RULE_SETUP ------------------ | | 1146| 384| YY_USER_ACTION | | ------------------ | | | | 890| 384|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 384| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 384|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 384|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1302| 384|#line 100 "/src/igraph/src/io/dl-lexer.l" 1303| 384|{ 1304| 384| return LABELSEMBEDDED; } 1305| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1306| 4|case 8: ------------------ | Branch (1306:1): [True: 4, False: 17.4M] ------------------ 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.02k|case 9: ------------------ | Branch (1312:1): [True: 1.02k, False: 17.4M] ------------------ 1313| 1.02k|YY_RULE_SETUP ------------------ | | 1146| 1.02k| YY_USER_ACTION | | ------------------ | | | | 890| 1.02k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.02k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.02k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.02k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1314| 1.02k|#line 104 "/src/igraph/src/io/dl-lexer.l" 1315| 1.02k|{ 1316| 1.02k| yyextra->mode=1; return FORMATEDGELIST1; } ------------------ | | 358| 1.02k|#define yyextra yyg->yyextra_r ------------------ 1317| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1318| 529|case 10: ------------------ | Branch (1318:1): [True: 529, False: 17.4M] ------------------ 1319| 529|YY_RULE_SETUP ------------------ | | 1146| 529| YY_USER_ACTION | | ------------------ | | | | 890| 529|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 529| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 529|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 529|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1320| 529|#line 106 "/src/igraph/src/io/dl-lexer.l" 1321| 529|{ 1322| 529| yyextra->mode=2; return FORMATNODELIST1; } ------------------ | | 358| 529|#define yyextra yyg->yyextra_r ------------------ 1323| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1324| 7.17k|case 11: ------------------ | Branch (1324:1): [True: 7.17k, False: 17.4M] ------------------ 1325| 7.17k|YY_RULE_SETUP ------------------ | | 1146| 7.17k| YY_USER_ACTION | | ------------------ | | | | 890| 7.17k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 7.17k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 7.17k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 7.17k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1326| 7.17k|#line 109 "/src/igraph/src/io/dl-lexer.l" 1327| 7.17k|{ /* eaten up */ } 1328| 7.17k| YY_BREAK ------------------ | | 1142| 7.17k|#define YY_BREAK /*LINTED*/break; ------------------ 1329| 1.74M|case 12: ------------------ | Branch (1329:1): [True: 1.74M, False: 15.7M] ------------------ 1330| 1.74M|YY_RULE_SETUP ------------------ | | 1146| 1.74M| YY_USER_ACTION | | ------------------ | | | | 890| 1.74M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.74M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.74M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.74M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1331| 1.74M|#line 110 "/src/igraph/src/io/dl-lexer.l" 1332| 1.74M|{ return LABEL; } 1333| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1334| 56.5k|case 13: ------------------ | Branch (1334:1): [True: 56.5k, False: 17.4M] ------------------ 1335| 56.5k|YY_RULE_SETUP ------------------ | | 1146| 56.5k| YY_USER_ACTION | | ------------------ | | | | 890| 56.5k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 56.5k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 56.5k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 56.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1336| 56.5k|#line 112 "/src/igraph/src/io/dl-lexer.l" 1337| 56.5k|{ return DIGIT; } 1338| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1339| 2.23k|case 14: ------------------ | Branch (1339:1): [True: 2.23k, False: 17.4M] ------------------ 1340| 2.23k|YY_RULE_SETUP ------------------ | | 1146| 2.23k| YY_USER_ACTION | | ------------------ | | | | 890| 2.23k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.23k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.23k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.23k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1341| 2.23k|#line 113 "/src/igraph/src/io/dl-lexer.l" 1342| 2.23k|{ 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.5M] ------------------ 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.72M|case 16: ------------------ | Branch (1349:1): [True: 4.72M, False: 12.7M] ------------------ 1350| 4.72M|YY_RULE_SETUP ------------------ | | 1146| 4.72M| YY_USER_ACTION | | ------------------ | | | | 890| 4.72M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 4.72M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 4.72M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 4.72M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1351| 4.72M|#line 116 "/src/igraph/src/io/dl-lexer.l" 1352| 4.72M|{ return NUM; } 1353| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1354| 1.62k|case 17: ------------------ | Branch (1354:1): [True: 1.62k, False: 17.4M] ------------------ 1355| 1.62k|YY_RULE_SETUP ------------------ | | 1146| 1.62k| YY_USER_ACTION | | ------------------ | | | | 890| 1.62k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.62k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.62k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.62k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1356| 1.62k|#line 117 "/src/igraph/src/io/dl-lexer.l" 1357| 1.62k|{ return LABEL; } 1358| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1359| 2.38M|case 18: ------------------ | Branch (1359:1): [True: 2.38M, False: 15.0M] ------------------ 1360| 2.38M|YY_RULE_SETUP ------------------ | | 1146| 2.38M| YY_USER_ACTION | | ------------------ | | | | 890| 2.38M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.38M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.38M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.38M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1361| 2.38M|#line 118 "/src/igraph/src/io/dl-lexer.l" 1362| 2.38M|{ } 1363| 2.38M| YY_BREAK ------------------ | | 1142| 2.38M|#define YY_BREAK /*LINTED*/break; ------------------ 1364| 1.52M|case 19: ------------------ | Branch (1364:1): [True: 1.52M, False: 15.9M] ------------------ 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| 7.66k|case 20: ------------------ | Branch (1369:1): [True: 7.66k, False: 17.4M] ------------------ 1370| 7.66k|YY_RULE_SETUP ------------------ | | 1146| 7.66k| YY_USER_ACTION | | ------------------ | | | | 890| 7.66k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 7.66k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 7.66k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 7.66k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1371| 7.66k|#line 121 "/src/igraph/src/io/dl-lexer.l" 1372| 7.66k|{ return LABEL; } 1373| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1374| 1.52M|case 21: ------------------ | Branch (1374:1): [True: 1.52M, False: 15.9M] ------------------ 1375| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1376| 1.52M|#line 122 "/src/igraph/src/io/dl-lexer.l" 1377| 1.52M|{ } 1378| 1.52M| YY_BREAK ------------------ | | 1142| 1.52M|#define YY_BREAK /*LINTED*/break; ------------------ 1379| 65|case 22: ------------------ | Branch (1379:1): [True: 65, False: 17.4M] ------------------ 1380| 65|YY_RULE_SETUP ------------------ | | 1146| 65| YY_USER_ACTION | | ------------------ | | | | 890| 65|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 65| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 65|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 65|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1381| 65|#line 124 "/src/igraph/src/io/dl-lexer.l" 1382| 65|{ /* eaten up */ } 1383| 65| YY_BREAK ------------------ | | 1142| 65|#define YY_BREAK /*LINTED*/break; ------------------ 1384| 842|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 842|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 842|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1384:1): [True: 842, False: 17.4M] ------------------ 1385| 914|case YY_STATE_EOF(LABELM): ------------------ | | 377| 914|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 914|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1385:1): [True: 72, False: 17.4M] ------------------ 1386| 1.35k|case YY_STATE_EOF(FULLMATRIX): ------------------ | | 377| 1.35k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.35k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1386:1): [True: 441, False: 17.4M] ------------------ 1387| 1.83k|case YY_STATE_EOF(EDGELIST): ------------------ | | 377| 1.83k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.83k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1387:1): [True: 476, False: 17.4M] ------------------ 1388| 2.22k|case YY_STATE_EOF(NODELIST): ------------------ | | 377| 2.22k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.22k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1388:1): [True: 394, False: 17.4M] ------------------ 1389| 2.22k|#line 126 "/src/igraph/src/io/dl-lexer.l" 1390| 2.22k|{ 1391| 2.22k| if (yyextra->eof) { ------------------ | | 358| 2.22k|#define yyextra yyg->yyextra_r ------------------ | Branch (1391:31): [True: 801, False: 1.42k] ------------------ 1392| 801| yyterminate(); ------------------ | | 1105| 801|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 801|#define YY_NULL 0 | | ------------------ ------------------ 1393| 1.42k| } else { 1394| 1.42k| yyextra->eof=1; ------------------ | | 358| 1.42k|#define yyextra yyg->yyextra_r ------------------ 1395| 1.42k| BEGIN(INITIAL); ------------------ | | 369| 1.42k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 904| 1.42k|#define INITIAL 0 ------------------ 1396| 1.42k| return EOFF; 1397| 1.42k| } 1398| 2.22k| } 1399| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1400| 157|case 23: ------------------ | Branch (1400:1): [True: 157, False: 17.4M] ------------------ 1401| 157|YY_RULE_SETUP ------------------ | | 1146| 157| YY_USER_ACTION | | ------------------ | | | | 890| 157|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 157| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 157|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 157|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1402| 157|#line 136 "/src/igraph/src/io/dl-lexer.l" 1403| 157|{ return 0; } 1404| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1405| 0|case 24: ------------------ | Branch (1405:1): [True: 0, False: 17.4M] ------------------ 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.7k| case YY_END_OF_BUFFER: ------------------ | | 594| 11.7k|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1412:2): [True: 11.7k, False: 17.4M] ------------------ 1413| 11.7k| { 1414| | /* Amount of text matched not including the EOB char. */ 1415| 11.7k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 577| 11.7k|#define yytext_ptr yytext_r ------------------ 1416| | 1417| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1418| 11.7k| *yy_cp = yyg->yy_hold_char; 1419| 11.7k| YY_RESTORE_YY_MORE_OFFSET 1420| | 1421| 11.7k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 527| 11.7k|#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.7k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1421:8): [True: 3.13k, False: 8.62k] ------------------ 1422| 3.13k| { 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.13k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 3.13k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1433| 3.13k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 527| 3.13k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 3.13k|#define yyin yyg->yyin_r ------------------ 1434| 3.13k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 527| 3.13k|#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.13k|#define YY_BUFFER_NORMAL 1 ------------------ 1435| 3.13k| } 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.7k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 527| 11.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1444:8): [True: 194, False: 11.5k] ------------------ 1445| 194| { /* This was really a NUL. */ 1446| 194| yy_state_type yy_next_state; 1447| | 1448| 194| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 194|#define yytext_ptr yytext_r ------------------ 1449| | 1450| 194| 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| 194| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1462| | 1463| 194| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 194|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 194|#define YY_MORE_ADJ 0 ------------------ 1464| | 1465| 194| if ( yy_next_state ) ------------------ | Branch (1465:9): [True: 66, False: 128] ------------------ 1466| 66| { 1467| | /* Consume the NUL. */ 1468| 66| yy_cp = ++yyg->yy_c_buf_p; 1469| 66| yy_current_state = yy_next_state; 1470| 66| goto yy_match; 1471| 66| } 1472| | 1473| 128| else 1474| 128| { 1475| 128| yy_cp = yyg->yy_c_buf_p; 1476| 128| goto yy_find_action; 1477| 128| } 1478| 194| } 1479| | 1480| 11.5k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1480:17): [True: 11.5k, False: 0] ------------------ 1481| 11.5k| { 1482| 2.22k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 2.22k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1482:4): [True: 2.22k, False: 9.34k] ------------------ 1483| 2.22k| { 1484| 2.22k| yyg->yy_did_buffer_switch_on_eof = 0; 1485| | 1486| 2.22k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 2.22k|#define yywrap igraph_dl_yywrap | | ------------------ | | | | 571| 2.22k|#define igraph_dl_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (571:37): [True: 2.22k, Folded] | | | | ------------------ | | ------------------ ------------------ 1487| 2.22k| { 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.22k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.22k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.22k|#define YY_MORE_ADJ 0 ------------------ 1498| | 1499| 2.22k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 2.22k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.22k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ 1500| 2.22k| goto do_action; 1501| 2.22k| } 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.22k| } 1510| | 1511| 7.27k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 7.27k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1511:4): [True: 7.27k, False: 4.29k] ------------------ 1512| 7.27k| yyg->yy_c_buf_p = 1513| 7.27k| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 7.27k|#define yytext_ptr yytext_r ------------------ 1514| | 1515| 7.27k| yy_current_state = yy_get_previous_state( yyscanner ); 1516| | 1517| 7.27k| yy_cp = yyg->yy_c_buf_p; 1518| 7.27k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 7.27k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 7.27k|#define YY_MORE_ADJ 0 ------------------ 1519| 7.27k| goto yy_match; 1520| | 1521| 2.07k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 2.07k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1521:4): [True: 2.07k, False: 9.49k] ------------------ 1522| 2.07k| yyg->yy_c_buf_p = 1523| 2.07k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 527| 2.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1524| | 1525| 2.07k| yy_current_state = yy_get_previous_state( yyscanner ); 1526| | 1527| 2.07k| yy_cp = yyg->yy_c_buf_p; 1528| 2.07k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.07k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.07k|#define YY_MORE_ADJ 0 ------------------ 1529| 2.07k| goto yy_find_action; 1530| 11.5k| } 1531| 0| break; 1532| 11.7k| } 1533| | 1534| 0| default: ------------------ | Branch (1534:2): [True: 0, False: 17.4M] ------------------ 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.4M| "fatal flex scanner internal error--no action found" ); 1537| 17.4M| } /* end of action switch */ 1538| 17.4M| } /* end of scanning one token */ 1539| 10.6M| } /* end of user's declarations */ 1540| 10.6M|} /* end of yylex */ igraph_dl_yyrestart: 1838| 2.22k|{ 1839| 2.22k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1840| | 1841| 2.22k| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 521| 2.22k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.22k, False: 0] | | ------------------ | | 522| 2.22k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.22k| : NULL) ------------------ | Branch (1841:7): [True: 0, False: 2.22k] ------------------ 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.22k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 50| 2.22k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 521| 2.22k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.22k, False: 0] | | ------------------ | | 522| 2.22k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.22k| : NULL) ------------------ 1848| 2.22k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.22k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1849| 2.22k|} igraph_dl_yy_create_buffer: 1903| 2.33k|{ 1904| 2.33k| YY_BUFFER_STATE b; 1905| | 1906| 2.33k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 1907| 2.33k| if ( ! b ) ------------------ | Branch (1907:7): [True: 0, False: 2.33k] ------------------ 1908| 2.33k| 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.33k| 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.33k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 1916| 2.33k| if ( ! b->yy_ch_buf ) ------------------ | Branch (1916:7): [True: 0, False: 2.33k] ------------------ 1917| 2.33k| 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.33k| b->yy_is_our_buffer = 1; 1920| | 1921| 2.33k| yy_init_buffer( b, file , yyscanner); ------------------ | | 50| 2.33k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ 1922| | 1923| 2.33k| return b; 1924| 2.33k|} igraph_dl_yy_delete_buffer: 1931| 2.33k|{ 1932| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1933| | 1934| 2.33k| if ( ! b ) ------------------ | Branch (1934:7): [True: 0, False: 2.33k] ------------------ 1935| 0| return; 1936| | 1937| 2.33k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.33k, False: 0] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ | Branch (1937:7): [True: 2.33k, False: 0] ------------------ 1938| 2.33k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 527| 2.33k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1939| | 1940| 2.33k| if ( b->yy_is_our_buffer ) ------------------ | Branch (1940:7): [True: 2.33k, False: 0] ------------------ 1941| 2.33k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 1942| | 1943| 2.33k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 1944| 2.33k|} igraph_dl_yy_flush_buffer: 1980| 4.56k|{ 1981| 4.56k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1982| 4.56k| if ( ! b ) ------------------ | Branch (1982:7): [True: 0, False: 4.56k] ------------------ 1983| 0| return; 1984| | 1985| 4.56k| 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.56k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.56k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1992| 4.56k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.56k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1993| | 1994| 4.56k| b->yy_buf_pos = &b->yy_ch_buf[0]; 1995| | 1996| 4.56k| b->yy_at_bol = 1; 1997| 4.56k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 498| 4.56k|#define YY_BUFFER_NEW 0 ------------------ 1998| | 1999| 4.56k| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 521| 4.56k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.56k, False: 0] | | ------------------ | | 522| 4.56k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.56k| : NULL) ------------------ | Branch (1999:7): [True: 2.22k, False: 2.33k] ------------------ 2000| 2.22k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.22k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2001| 4.56k|} igraph_dl_yypop_buffer_state: 2041| 2.33k|{ 2042| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2043| 2.33k| if (!YY_CURRENT_BUFFER) ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.33k, False: 0] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ | Branch (2043:6): [True: 2.33k, False: 0] ------------------ 2044| 2.33k| 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| 8.00M|{ 2279| 8.00M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2280| 8.00M| return yyleng; ------------------ | | 359| 8.00M|#define yyleng yyg->yyleng_r ------------------ 2281| 8.00M|} igraph_dl_yyget_text: 2288| 8.06M|{ 2289| 8.06M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2290| 8.06M| return yytext; ------------------ | | 360| 8.06M|#define yytext yyg->yytext_r ------------------ 2291| 8.06M|} igraph_dl_yyset_extra: 2298| 4.67k|{ 2299| 4.67k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2300| 4.67k| yyextra = user_defined ; ------------------ | | 358| 4.67k|#define yyextra yyg->yyextra_r ------------------ 2301| 4.67k|} igraph_dl_yyset_in: 2340| 2.33k|{ 2341| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2342| 2.33k| yyin = _in_str ; ------------------ | | 356| 2.33k|#define yyin yyg->yyin_r ------------------ 2343| 2.33k|} igraph_dl_yylex_init_extra: 2423| 2.33k|{ 2424| 2.33k| struct yyguts_t dummy_yyguts; 2425| | 2426| 2.33k| yyset_extra (yy_user_defined, &dummy_yyguts); ------------------ | | 140| 2.33k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2427| | 2428| 2.33k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2428:9): [True: 0, False: 2.33k] ------------------ 2429| 0| errno = EINVAL; 2430| 0| return 1; 2431| 0| } 2432| | 2433| 2.33k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 2434| | 2435| 2.33k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2435:9): [True: 0, False: 2.33k] ------------------ 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.33k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2443| | 2444| 2.33k| yyset_extra (yy_user_defined, *ptr_yy_globals); ------------------ | | 140| 2.33k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2445| | 2446| 2.33k| return yy_init_globals ( *ptr_yy_globals ); 2447| 2.33k|} igraph_dl_yylex_destroy: 2484| 2.33k|{ 2485| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2486| | 2487| | /* Pop the buffer stack, destroying each element. */ 2488| 4.67k| while(YY_CURRENT_BUFFER){ ------------------ | | 521| 4.67k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:27): [True: 2.33k, False: 2.33k] | | | Branch (521:29): [True: 4.67k, False: 0] | | ------------------ | | 522| 4.67k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.67k| : NULL) ------------------ 2489| 2.33k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 2.33k|#define yy_delete_buffer igraph_dl_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 521| 2.33k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.33k, False: 0] | | ------------------ | | 522| 2.33k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.33k| : NULL) ------------------ 2490| 2.33k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 2.33k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2491| 2.33k| yypop_buffer_state(yyscanner); ------------------ | | 80| 2.33k|#define yypop_buffer_state igraph_dl_yypop_buffer_state ------------------ 2492| 2.33k| } 2493| | 2494| | /* Destroy the stack itself. */ 2495| 2.33k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 2496| 2.33k| yyg->yy_buffer_stack = NULL; 2497| | 2498| | /* Destroy the start condition stack. */ 2499| 2.33k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 2500| 2.33k| 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.33k| yy_init_globals( yyscanner); 2505| | 2506| | /* Destroy the main struct (reentrant only). */ 2507| 2.33k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 2.33k|#define yyfree igraph_dl_yyfree ------------------ 2508| | yyscanner = NULL; 2509| 2.33k| return 0; 2510| 2.33k|} igraph_dl_yyalloc: 2540| 9.34k|{ 2541| 9.34k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2542| 9.34k| (void)yyg; 2543| 9.34k| return malloc(size); 2544| 9.34k|} 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.5k|{ 1551| 11.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1552| 11.5k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1553| 11.5k| char *source = yyg->yytext_ptr; ------------------ | | 577| 11.5k|#define yytext_ptr yytext_r ------------------ 1554| 11.5k| int number_to_move, i; 1555| 11.5k| int ret_val; 1556| | 1557| 11.5k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1557:7): [True: 0, False: 11.5k] ------------------ 1558| 11.5k| 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.5k| "fatal flex scanner internal error--end of buffer missed" ); 1560| | 1561| 11.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1561:7): [True: 0, False: 11.5k] ------------------ 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.5k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 577| 11.5k|#define yytext_ptr yytext_r ------------------ 1584| | 1585| 261M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1585:15): [True: 261M, False: 11.5k] ------------------ 1586| 261M| *(dest++) = *(source++); 1587| | 1588| 11.5k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 527| 11.5k|#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.5k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1588:7): [True: 1.27k, 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.27k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 527| 1.27k|#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.61k, False: 680] ------------------ 1638| 9.61k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1052| 9.61k|#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.02k|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1085:11): [True: 3.02k, False: 7.27k] | | | Branch (1085:78): [True: 0, False: 3.02k] | | ------------------ | | 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.5k| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1647:7): [True: 4.29k, False: 7.27k] ------------------ 1648| 4.29k| { 1649| 4.29k| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 836| 4.29k|#define YY_MORE_ADJ 0 ------------------ | Branch (1649:8): [True: 2.22k, False: 2.07k] ------------------ 1650| 2.22k| { 1651| 2.22k| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 2.22k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1652| 2.22k| yyrestart( yyin , yyscanner); ------------------ | | 98| 2.22k|#define yyrestart igraph_dl_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 2.22k|#define yyin yyg->yyin_r ------------------ 1653| 2.22k| } 1654| | 1655| 2.07k| else 1656| 2.07k| { 1657| 2.07k| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 2.07k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1658| 2.07k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 527| 2.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1659| 2.07k| YY_BUFFER_EOF_PENDING; ------------------ | | 510| 2.07k|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1660| 2.07k| } 1661| 4.29k| } 1662| | 1663| 7.27k| else 1664| 7.27k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 7.27k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1665| | 1666| 11.5k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1666:6): [True: 0, False: 11.5k] ------------------ 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.5k| yyg->yy_n_chars += number_to_move; 1678| 11.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.5k|#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.5k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1679| 11.5k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.5k|#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.5k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1680| | 1681| 11.5k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 577| 11.5k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 527| 11.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1682| | 1683| 11.5k| return ret_val; 1684| 11.5k|} dl-lexer.c:yy_get_previous_state: 1689| 9.53k|{ 1690| 9.53k| yy_state_type yy_current_state; 1691| 9.53k| char *yy_cp; 1692| 9.53k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1693| | 1694| 9.53k| yy_current_state = yyg->yy_start; 1695| | 1696| 262M| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 577| 9.53k|#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.53k|#define YY_MORE_ADJ 0 ------------------ | Branch (1696:47): [True: 262M, False: 9.53k] ------------------ 1697| 262M| { 1698| 262M| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 46); ------------------ | | 346| 262M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1698:19): [True: 262M, False: 60] ------------------ 1699| 262M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1699:8): [True: 261M, False: 1.58M] ------------------ 1700| 261M| { 1701| 261M| yyg->yy_last_accepting_state = yy_current_state; 1702| 261M| yyg->yy_last_accepting_cpos = yy_cp; 1703| 261M| } 1704| 316M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1704:11): [True: 53.5M, False: 262M] ------------------ 1705| 53.5M| { 1706| 53.5M| yy_current_state = (int) yy_def[yy_current_state]; 1707| 53.5M| if ( yy_current_state >= 129 ) ------------------ | Branch (1707:9): [True: 52.1M, False: 1.44M] ------------------ 1708| 52.1M| yy_c = yy_meta[yy_c]; 1709| 53.5M| } 1710| 262M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1711| 262M| } 1712| | 1713| 9.53k| return yy_current_state; 1714| 9.53k|} dl-lexer.c:yy_try_NUL_trans: 1722| 194|{ 1723| 194| int yy_is_jam; 1724| 194| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ 1725| 194| char *yy_cp = yyg->yy_c_buf_p; 1726| | 1727| 194| YY_CHAR yy_c = 46; 1728| 194| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1728:7): [True: 110, False: 84] ------------------ 1729| 110| { 1730| 110| yyg->yy_last_accepting_state = yy_current_state; 1731| 110| yyg->yy_last_accepting_cpos = yy_cp; 1732| 110| } 1733| 398| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1733:10): [True: 204, False: 194] ------------------ 1734| 204| { 1735| 204| yy_current_state = (int) yy_def[yy_current_state]; 1736| 204| if ( yy_current_state >= 129 ) ------------------ | Branch (1736:8): [True: 61, False: 143] ------------------ 1737| 61| yy_c = yy_meta[yy_c]; 1738| 204| } 1739| 194| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1740| 194| yy_is_jam = (yy_current_state == 128); 1741| | 1742| 194| (void)yyg; 1743| 194| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (1743:9): [True: 128, False: 66] ------------------ 1744| 194|} dl-lexer.c:igraph_dl_yy_load_buffer_state: 1888| 6.78k|{ 1889| 6.78k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1890| 6.78k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 6.78k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1891| 6.78k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 577| 6.78k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 527| 6.78k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1892| 6.78k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 6.78k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 527| 6.78k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1893| 6.78k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1894| 6.78k|} dl-lexer.c:igraph_dl_yy_init_buffer: 1952| 4.56k|{ 1953| 4.56k| int oerrno = errno; 1954| 4.56k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1955| | 1956| 4.56k| yy_flush_buffer( b , yyscanner); ------------------ | | 56| 4.56k|#define yy_flush_buffer igraph_dl_yy_flush_buffer ------------------ 1957| | 1958| 4.56k| b->yy_input_file = file; 1959| 4.56k| 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.56k| if (b != YY_CURRENT_BUFFER){ ------------------ | | 521| 4.56k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.56k, False: 0] | | ------------------ | | 522| 4.56k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.56k| : NULL) ------------------ | Branch (1965:9): [True: 2.33k, False: 2.22k] ------------------ 1966| 2.33k| b->yy_bs_lineno = 1; 1967| 2.33k| b->yy_bs_column = 0; 1968| 2.33k| } 1969| | 1970| 4.56k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (1970:32): [True: 4.56k, False: 0] ------------------ 1971| | 1972| | errno = oerrno; 1973| 4.56k|} dl-lexer.c:igraph_dl_yyensure_buffer_stack: 2061| 2.33k|{ 2062| 2.33k| yy_size_t num_to_alloc; 2063| 2.33k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2064| | 2065| 2.33k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2065:6): [True: 2.33k, 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.33k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2072| 2.33k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 2.33k|#define yyalloc igraph_dl_yyalloc ------------------ 2073| 2.33k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2074| 2.33k| , yyscanner); 2075| 2.33k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2075:8): [True: 0, False: 2.33k] ------------------ 2076| 2.33k| 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.33k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2079| | 2080| 2.33k| yyg->yy_buffer_stack_max = num_to_alloc; 2081| 2.33k| yyg->yy_buffer_stack_top = 0; 2082| 2.33k| return; 2083| 2.33k| } 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.67k|{ 2451| 4.67k| 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.67k| yyg->yy_buffer_stack = NULL; 2457| 4.67k| yyg->yy_buffer_stack_top = 0; 2458| 4.67k| yyg->yy_buffer_stack_max = 0; 2459| 4.67k| yyg->yy_c_buf_p = NULL; 2460| 4.67k| yyg->yy_init = 0; 2461| 4.67k| yyg->yy_start = 0; 2462| | 2463| 4.67k| yyg->yy_start_stack_ptr = 0; 2464| 4.67k| yyg->yy_start_stack_depth = 0; 2465| 4.67k| 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.67k| yyin = NULL; ------------------ | | 356| 4.67k|#define yyin yyg->yyin_r ------------------ 2473| 4.67k| yyout = NULL; ------------------ | | 357| 4.67k|#define yyout yyg->yyout_r ------------------ 2474| 4.67k|#endif 2475| | 2476| | /* For future reference: Set errno on error, since we are called by 2477| | * yylex_init() 2478| | */ 2479| 4.67k| return 0; 2480| 4.67k|} igraph_dl_yyparse: 1291| 2.33k|{ 1292| |/* The lookahead symbol. */ 1293| 2.33k|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.33k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 370| 2.33k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1300| 2.33k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 370| 2.33k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1301| | 1302| |/* Location data for the lookahead symbol. */ 1303| 2.33k|static YYLTYPE yyloc_default 1304| 2.33k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1305| 2.33k| = { 1, 1, 1, 1 } 1306| 2.33k|# endif 1307| 2.33k|; 1308| 2.33k|YYLTYPE yylloc = yyloc_default; 1309| | 1310| | /* Number of syntax errors so far. */ 1311| 2.33k| int yynerrs; 1312| | 1313| 2.33k| yy_state_fast_t yystate; 1314| | /* Number of tokens to shift before error messages enabled. */ 1315| 2.33k| 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.33k| yy_state_t yyssa[YYINITDEPTH]; 1327| 2.33k| yy_state_t *yyss; 1328| 2.33k| yy_state_t *yyssp; 1329| | 1330| | /* The semantic value stack. */ 1331| 2.33k| YYSTYPE yyvsa[YYINITDEPTH]; 1332| 2.33k| YYSTYPE *yyvs; 1333| 2.33k| YYSTYPE *yyvsp; 1334| | 1335| | /* The location stack. */ 1336| 2.33k| YYLTYPE yylsa[YYINITDEPTH]; 1337| 2.33k| YYLTYPE *yyls; 1338| 2.33k| YYLTYPE *yylsp; 1339| | 1340| | /* The locations where the error started and ended. */ 1341| 2.33k| YYLTYPE yyerror_range[3]; 1342| | 1343| 2.33k| YYPTRDIFF_T yystacksize; ------------------ | | 285| 2.33k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1344| | 1345| 2.33k| int yyn; 1346| 2.33k| int yyresult; 1347| | /* Lookahead token as an internal (translated) token number. */ 1348| 2.33k| int yytoken = 0; 1349| | /* The variables used to return semantic value and location from the 1350| | action routines. */ 1351| 2.33k| YYSTYPE yyval; 1352| 2.33k| YYLTYPE yyloc; 1353| | 1354| 2.33k|#if YYERROR_VERBOSE 1355| | /* Buffer for error messages, and its allocated size. */ 1356| 2.33k| char yymsgbuf[128]; 1357| 2.33k| char *yymsg = yymsgbuf; 1358| 2.33k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 285| 2.33k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1359| 2.33k|#endif 1360| | 1361| 2.33k|#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.33k| int yylen = 0; 1366| | 1367| 2.33k| yyssp = yyss = yyssa; 1368| 2.33k| yyvsp = yyvs = yyvsa; 1369| 2.33k| yylsp = yyls = yylsa; 1370| 2.33k| yystacksize = YYINITDEPTH; ------------------ | | 1016| 2.33k|# define YYINITDEPTH 200 ------------------ 1371| | 1372| 2.33k| YYDPRINTF ((stderr, "Starting parse\n")); 1373| | 1374| 2.33k| yystate = 0; 1375| 2.33k| yyerrstatus = 0; 1376| 2.33k| yynerrs = 0; ------------------ | | 71| 2.33k|#define yynerrs igraph_dl_yynerrs ------------------ 1377| 2.33k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 780| 2.33k|#define YYEMPTY (-2) ------------------ 1378| 2.33k| yylsp[0] = yylloc; 1379| 2.33k| goto yysetstate; 1380| | 1381| | 1382| |/*------------------------------------------------------------. 1383| || yynewstate -- push a new state, which is found in yystate. | 1384| |`------------------------------------------------------------*/ 1385| 26.7M|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.7M| yyssp++; 1389| | 1390| | 1391| |/*--------------------------------------------------------------------. 1392| || yysetstate -- set current state (the top of the stack) to yystate. | 1393| |`--------------------------------------------------------------------*/ 1394| 26.7M|yysetstate: 1395| 26.7M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1396| 26.7M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 393| 26.7M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (393:31): [Folded, False: 26.7M] | | | Branch (393:37): [True: 0, False: 0] | | | Branch (393:37): [True: 0, False: 0] | | ------------------ ------------------ 1397| 26.7M| YY_IGNORE_USELESS_CAST_BEGIN 1398| 26.7M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 126| 26.7M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1399| 26.7M| YY_IGNORE_USELESS_CAST_END 1400| | 1401| 26.7M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1401:7): [True: 0, False: 26.7M] ------------------ 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.7M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1468| | 1469| 26.7M| if (yystate == YYFINAL) ------------------ | | 527| 26.7M|#define YYFINAL 4 ------------------ | Branch (1469:7): [True: 820, False: 26.7M] ------------------ 1470| 820| YYACCEPT; ------------------ | | 783| 820|#define YYACCEPT goto yyacceptlab ------------------ 1471| | 1472| 26.7M| goto yybackup; 1473| | 1474| | 1475| |/*-----------. 1476| || yybackup. | 1477| |`-----------*/ 1478| 26.7M|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.7M| yyn = yypact[yystate]; 1484| 26.7M| if (yypact_value_is_default (yyn)) ------------------ | | 632| 26.7M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 26.7M|#define YYPACT_NINF (-114) | | ------------------ | | | Branch (632:3): [True: 14.5M, False: 12.2M] | | ------------------ ------------------ 1485| 14.5M| 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| 12.2M| if (yychar == YYEMPTY) ------------------ | | 780| 12.2M|#define YYEMPTY (-2) ------------------ | Branch (1490:7): [True: 10.6M, False: 1.56M] ------------------ 1491| 10.6M| { 1492| 10.6M| YYDPRINTF ((stderr, "Reading a token: ")); 1493| 10.6M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 68| 10.6M|#define yylex igraph_dl_yylex ------------------ yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 116| 10.6M|#define scanner context->scanner ------------------ 1494| 10.6M| } 1495| | 1496| 12.2M| if (yychar <= YYEOF) ------------------ | | 781| 12.2M|#define YYEOF 0 ------------------ | Branch (1496:7): [True: 1.02k, False: 12.2M] ------------------ 1497| 1.02k| { 1498| 1.02k| yychar = yytoken = YYEOF; ------------------ | | 781| 1.02k|#define YYEOF 0 ------------------ 1499| 1.02k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1500| 1.02k| } 1501| 12.2M| else 1502| 12.2M| { 1503| 12.2M| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 12.2M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 12.2M|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 12.2M, False: 0] | | | Branch (547:18): [True: 12.2M, False: 0] | | ------------------ ------------------ 1504| 12.2M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1505| 12.2M| } 1506| | 1507| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1508| | detect an error, take that action. */ 1509| 12.2M| yyn += yytoken; 1510| 12.2M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 529| 12.2M|#define YYLAST 118 ------------------ | Branch (1510:7): [True: 0, False: 12.2M] | Branch (1510:18): [True: 0, False: 12.2M] | Branch (1510:34): [True: 1.55M, False: 10.6M] ------------------ 1511| 1.55M| goto yydefault; 1512| 10.6M| yyn = yytable[yyn]; 1513| 10.6M| if (yyn <= 0) ------------------ | Branch (1513:7): [True: 11.8k, False: 10.6M] ------------------ 1514| 11.8k| { 1515| 11.8k| if (yytable_value_is_error (yyn)) ------------------ | | 637| 11.8k| 0 | | ------------------ | | | Branch (637:3): [Folded, False: 11.8k] | | ------------------ ------------------ 1516| 0| goto yyerrlab; 1517| 11.8k| yyn = -yyn; 1518| 11.8k| goto yyreduce; 1519| 11.8k| } 1520| | 1521| | /* Count tokens shifted since error; after three, turn off error 1522| | status. */ 1523| 10.6M| if (yyerrstatus) ------------------ | Branch (1523:7): [True: 0, False: 10.6M] ------------------ 1524| 0| yyerrstatus--; 1525| | 1526| | /* Shift the lookahead token. */ 1527| 10.6M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1528| 10.6M| yystate = yyn; 1529| 10.6M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1530| 10.6M| *++yyvsp = yylval; 1531| 10.6M| YY_IGNORE_MAYBE_UNINITIALIZED_END 1532| 10.6M| *++yylsp = yylloc; 1533| | 1534| | /* Discard the shifted token. */ 1535| 10.6M| yychar = YYEMPTY; ------------------ | | 780| 10.6M|#define YYEMPTY (-2) ------------------ 1536| 10.6M| goto yynewstate; 1537| | 1538| | 1539| |/*-----------------------------------------------------------. 1540| || yydefault -- do the default action for the current state. | 1541| |`-----------------------------------------------------------*/ 1542| 16.1M|yydefault: 1543| 16.1M| yyn = yydefact[yystate]; 1544| 16.1M| if (yyn == 0) ------------------ | Branch (1544:7): [True: 832, False: 16.1M] ------------------ 1545| 832| goto yyerrlab; 1546| 16.1M| goto yyreduce; 1547| | 1548| | 1549| |/*-----------------------------. 1550| || yyreduce -- do a reduction. | 1551| |`-----------------------------*/ 1552| 16.1M|yyreduce: 1553| | /* yyn is the number of a rule to reduce with. */ 1554| 16.1M| 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| 16.1M| yyval = yyvsp[1-yylen]; 1565| | 1566| | /* Default location. */ 1567| 16.1M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 818| 16.1M| do \ | | 819| 16.1M| if (N) \ | | ------------------ | | | Branch (819:11): [True: 14.5M, False: 1.57M] | | ------------------ | | 820| 16.1M| { \ | | 821| 14.5M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 836| 14.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 822| 14.5M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 836| 14.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 823| 14.5M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 836| 14.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 824| 14.5M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 836| 14.5M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 825| 14.5M| } \ | | 826| 16.1M| else \ | | 827| 16.1M| { \ | | 828| 1.57M| (Current).first_line = (Current).last_line = \ | | 829| 1.57M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 836| 1.57M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 830| 1.57M| (Current).first_column = (Current).last_column = \ | | 831| 1.57M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 836| 1.57M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 832| 1.57M| } \ | | 833| 16.1M| while (0) | | ------------------ | | | Branch (833:12): [Folded, False: 16.1M] | | ------------------ ------------------ 1568| 16.1M| yyerror_range[1] = yyloc; 1569| 16.1M| YY_REDUCE_PRINT (yyn); 1570| 16.1M| switch (yyn) 1571| 16.1M| { 1572| 905| case 2: ------------------ | Branch (1572:3): [True: 905, False: 16.1M] ------------------ 1573| 905|#line 104 "/src/igraph/src/io/dl-parser.y" 1574| 905| { 1575| 905| context->n=(yyvsp[-4].integer); 1576| 905| if (context->n < 0) { ------------------ | Branch (1576:7): [True: 0, False: 905] ------------------ 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| 905| if (context->n > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 905|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (1579:7): [True: 47, False: 858] ------------------ 1580| 47| IGRAPH_YY_ERRORF("Vertex count too large in DL file (%" IGRAPH_PRId ").", IGRAPH_EINVAL, context->n); ------------------ | | 24| 47| do { \ | | 25| 47| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 47| error_code, __VA_ARGS__) ; \ | | 27| 47| context->igraph_errno = error_code; \ | | 28| 47| YYABORT; \ | | ------------------ | | | | 784| 47|#define YYABORT goto yyabortlab | | ------------------ | | 29| 47| } while (0) | | ------------------ | | | Branch (29:14): [Folded, False: 0] | | ------------------ ------------------ 1581| 47| } 1582| 905|} 1583| 858|#line 1584 "/src/igraph/build/src/io/parsers/dl-parser.c" 1584| 858| break; 1585| | 1586| 858| case 7: ------------------ | Branch (1586:3): [True: 452, False: 16.1M] ------------------ 1587| 452|#line 118 "/src/igraph/src/io/dl-parser.y" 1588| 452| { context->type=IGRAPH_DL_MATRIX; } 1589| 452|#line 1590 "/src/igraph/build/src/io/parsers/dl-parser.c" 1590| 452| break; 1591| | 1592| 344| case 8: ------------------ | Branch (1592:3): [True: 344, False: 16.1M] ------------------ 1593| 344|#line 119 "/src/igraph/src/io/dl-parser.y" 1594| 344| { context->type=IGRAPH_DL_EDGELIST1; } 1595| 344|#line 1596 "/src/igraph/build/src/io/parsers/dl-parser.c" 1596| 344| break; 1597| | 1598| 109| case 9: ------------------ | Branch (1598:3): [True: 109, False: 16.1M] ------------------ 1599| 109|#line 120 "/src/igraph/src/io/dl-parser.y" 1600| 109| { context->type=IGRAPH_DL_NODELIST1; } 1601| 109|#line 1602 "/src/igraph/build/src/io/parsers/dl-parser.c" 1602| 109| break; 1603| | 1604| 0| case 10: ------------------ | Branch (1604:3): [True: 0, False: 16.1M] ------------------ 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| 452| case 11: ------------------ | Branch (1610:3): [True: 452, False: 16.1M] ------------------ 1611| 452|#line 123 "/src/igraph/src/io/dl-parser.y" 1612| 452| {} 1613| 452|#line 1614 "/src/igraph/build/src/io/parsers/dl-parser.c" 1614| 452| break; 1615| | 1616| 355| case 14: ------------------ | Branch (1616:3): [True: 355, False: 16.1M] ------------------ 1617| 355|#line 127 "/src/igraph/src/io/dl-parser.y" 1618| 355| { } 1619| 355|#line 1620 "/src/igraph/build/src/io/parsers/dl-parser.c" 1620| 355| break; 1621| | 1622| 82| case 15: ------------------ | Branch (1622:3): [True: 82, False: 16.1M] ------------------ 1623| 82|#line 128 "/src/igraph/src/io/dl-parser.y" 1624| 82| { } 1625| 82|#line 1626 "/src/igraph/build/src/io/parsers/dl-parser.c" 1626| 82| break; 1627| | 1628| 15| case 16: ------------------ | Branch (1628:3): [True: 15, False: 16.1M] ------------------ 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| 344| case 17: ------------------ | Branch (1634:3): [True: 344, False: 16.1M] ------------------ 1635| 344|#line 132 "/src/igraph/src/io/dl-parser.y" 1636| 344| {} 1637| 344|#line 1638 "/src/igraph/build/src/io/parsers/dl-parser.c" 1638| 344| break; 1639| | 1640| 1.74M| case 18: ------------------ | Branch (1640:3): [True: 1.74M, False: 14.3M] ------------------ 1641| 1.74M|#line 133 "/src/igraph/src/io/dl-parser.y" 1642| 1.74M| { 1643| 1.74M| IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.74M| do { \ | | 11| 1.74M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.74M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.74M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.74M] | | | | ------------------ | | ------------------ | | 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.74M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.74M] | | ------------------ ------------------ 1644| 1.74M| igraph_dl_yyget_leng(scanner), 1645| 1.74M| context)); } 1646| 1.74M|#line 1647 "/src/igraph/build/src/io/parsers/dl-parser.c" 1647| 1.74M| break; 1648| | 1649| 1.74M| case 19: ------------------ | Branch (1649:3): [True: 464, False: 16.1M] ------------------ 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.8k| case 20: ------------------ | Branch (1655:3): [True: 11.8k, False: 16.1M] ------------------ 1656| 11.8k|#line 139 "/src/igraph/src/io/dl-parser.y" 1657| 11.8k| { 1658| 11.8k| context->from += 1; 1659| 11.8k| context->to = 0; 1660| 11.8k| } 1661| 11.8k|#line 1662 "/src/igraph/build/src/io/parsers/dl-parser.c" 1662| 11.8k| break; 1663| | 1664| 56.5k| case 22: ------------------ | Branch (1664:3): [True: 56.5k, False: 16.0M] ------------------ 1665| 56.5k|#line 144 "/src/igraph/src/io/dl-parser.y" 1666| 56.5k| { } 1667| 56.5k|#line 1668 "/src/igraph/build/src/io/parsers/dl-parser.c" 1668| 56.5k| break; 1669| | 1670| 56.5k| case 23: ------------------ | Branch (1670:3): [True: 56.5k, False: 16.0M] ------------------ 1671| 56.5k|#line 146 "/src/igraph/src/io/dl-parser.y" 1672| 56.5k| { 1673| | /* TODO: What if the digit is neither 0 or 1? Are multigraphs allowed? */ 1674| 56.5k| char c = igraph_dl_yyget_text(scanner)[0]; ------------------ | | 116| 56.5k|#define scanner context->scanner ------------------ 1675| 56.5k| if (c == '1') { ------------------ | Branch (1675:7): [True: 55.7k, False: 821] ------------------ 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: 4, False: 817] ------------------ 1681| 4| IGRAPH_YY_ERRORF("Unexpected digit '%c' in adjacency matrix in DL file.", ------------------ | | 24| 4| do { \ | | 25| 4| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 4| error_code, __VA_ARGS__) ; \ | | 27| 4| context->igraph_errno = error_code; \ | | 28| 4| YYABORT; \ | | ------------------ | | | | 784| 4|#define YYABORT goto yyabortlab | | ------------------ | | 29| 4| } while (0) | | ------------------ | | | Branch (29:14): [Folded, False: 0] | | ------------------ ------------------ 1682| 4| IGRAPH_EINVAL, c); 1683| 4| } 1684| 56.5k| context->to += 1; 1685| 56.5k|} 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: 16.1M] ------------------ 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: 16.1M] ------------------ 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.98k| case 28: ------------------ | Branch (1701:3): [True: 1.98k, False: 16.1M] ------------------ 1702| 1.98k|#line 167 "/src/igraph/src/io/dl-parser.y" 1703| 1.98k| { IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.98k| do { \ | | 11| 1.98k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.98k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.98k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.98k] | | | | ------------------ | | ------------------ | | 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.98k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.98k] | | ------------------ ------------------ 1704| 1.98k| igraph_dl_yyget_leng(scanner), 1705| 1.98k| context)); } 1706| 1.98k|#line 1707 "/src/igraph/build/src/io/parsers/dl-parser.c" 1707| 1.98k| break; 1708| | 1709| 1.98k| case 29: ------------------ | Branch (1709:3): [True: 17, False: 16.1M] ------------------ 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| 194| case 30: ------------------ | Branch (1718:3): [True: 194, False: 16.1M] ------------------ 1719| 194|#line 175 "/src/igraph/src/io/dl-parser.y" 1720| 194| { 1721| 194| context->from += 1; 1722| 194| context->to = 0; 1723| 194| } 1724| 194|#line 1725 "/src/igraph/build/src/io/parsers/dl-parser.c" 1725| 194| break; 1726| | 1727| 211| case 31: ------------------ | Branch (1727:3): [True: 211, False: 16.1M] ------------------ 1728| 211|#line 180 "/src/igraph/src/io/dl-parser.y" 1729| 211| { } 1730| 211|#line 1731 "/src/igraph/build/src/io/parsers/dl-parser.c" 1731| 211| break; 1732| | 1733| 344| case 32: ------------------ | Branch (1733:3): [True: 344, False: 16.1M] ------------------ 1734| 344|#line 184 "/src/igraph/src/io/dl-parser.y" 1735| 344| {} 1736| 344|#line 1737 "/src/igraph/build/src/io/parsers/dl-parser.c" 1737| 344| break; 1738| | 1739| 316| case 33: ------------------ | Branch (1739:3): [True: 316, False: 16.1M] ------------------ 1740| 316|#line 186 "/src/igraph/src/io/dl-parser.y" 1741| 316| {} 1742| 316|#line 1743 "/src/igraph/build/src/io/parsers/dl-parser.c" 1743| 316| break; 1744| | 1745| 3| case 34: ------------------ | Branch (1745:3): [True: 3, False: 16.1M] ------------------ 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| 20| case 35: ------------------ | Branch (1751:3): [True: 20, False: 16.1M] ------------------ 1752| 20|#line 188 "/src/igraph/src/io/dl-parser.y" 1753| 20| {} 1754| 20|#line 1755 "/src/igraph/build/src/io/parsers/dl-parser.c" 1755| 20| break; 1756| | 1757| 5| case 36: ------------------ | Branch (1757:3): [True: 5, False: 16.1M] ------------------ 1758| 5|#line 189 "/src/igraph/src/io/dl-parser.y" 1759| 5| {} 1760| 5|#line 1761 "/src/igraph/build/src/io/parsers/dl-parser.c" 1761| 5| break; 1762| | 1763| 0| case 37: ------------------ | Branch (1763:3): [True: 0, False: 16.1M] ------------------ 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| 878| case 38: ------------------ | Branch (1769:3): [True: 878, False: 16.1M] ------------------ 1770| 878|#line 193 "/src/igraph/src/io/dl-parser.y" 1771| 878| {} 1772| 878|#line 1773 "/src/igraph/build/src/io/parsers/dl-parser.c" 1773| 878| break; 1774| | 1775| 2.34M| case 39: ------------------ | Branch (1775:3): [True: 2.34M, False: 13.7M] ------------------ 1776| 2.34M|#line 194 "/src/igraph/src/io/dl-parser.y" 1777| 2.34M| {} 1778| 2.34M|#line 1779 "/src/igraph/build/src/io/parsers/dl-parser.c" 1779| 2.34M| break; 1780| | 1781| 38.6k| case 40: ------------------ | Branch (1781:3): [True: 38.6k, False: 16.1M] ------------------ 1782| 38.6k|#line 197 "/src/igraph/src/io/dl-parser.y" 1783| 38.6k| { 1784| 38.6k| igraph_int_t from = (yyvsp[-3].integer), to = (yyvsp[-2].integer); 1785| 38.6k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 38.6k| do { \ | | 11| 38.6k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 38.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 38.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 123, False: 38.5k] | | | | ------------------ | | ------------------ | | 13| 123| context->igraph_errno = igraph_i_ret; \ | | 14| 123| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 123|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 123| YYABORT; \ | | ------------------ | | | | 784| 123|#define YYABORT goto yyabortlab | | ------------------ | | 16| 123| } \ | | 17| 38.6k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 38.5k] | | ------------------ ------------------ 1786| 38.5k| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 38.5k| do { \ | | 11| 38.5k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 38.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 38.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 135, False: 38.4k] | | | | ------------------ | | ------------------ | | 13| 135| context->igraph_errno = igraph_i_ret; \ | | 14| 135| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 135|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 135| YYABORT; \ | | ------------------ | | | | 784| 135|#define YYABORT goto yyabortlab | | ------------------ | | 16| 135| } \ | | 17| 38.5k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 38.4k] | | ------------------ ------------------ 1787| 38.4k| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w(from-1, to-1, (yyvsp[-1].real), context)); } ------------------ | | 10| 38.4k| do { \ | | 11| 38.4k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 38.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 38.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 38.4k] | | | | ------------------ | | ------------------ | | 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| 38.4k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 38.4k] | | ------------------ ------------------ 1788| 38.4k|#line 1789 "/src/igraph/build/src/io/parsers/dl-parser.c" 1789| 38.4k| break; 1790| | 1791| 2.30M| case 41: ------------------ | Branch (1791:3): [True: 2.30M, False: 13.8M] ------------------ 1792| 2.30M|#line 202 "/src/igraph/src/io/dl-parser.y" 1793| 2.30M| { 1794| 2.30M| igraph_int_t from = (yyvsp[-2].integer), to = (yyvsp[-1].integer); 1795| 2.30M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(from)); ------------------ | | 10| 2.30M| do { \ | | 11| 2.30M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.30M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 2.30M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 124, False: 2.30M] | | | | ------------------ | | ------------------ | | 13| 124| context->igraph_errno = igraph_i_ret; \ | | 14| 124| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 124|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 124| YYABORT; \ | | ------------------ | | | | 784| 124|#define YYABORT goto yyabortlab | | ------------------ | | 16| 124| } \ | | 17| 2.30M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 2.30M] | | ------------------ ------------------ 1796| 2.30M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 2.30M| do { \ | | 11| 2.30M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.30M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 2.30M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 82, False: 2.30M] | | | | ------------------ | | ------------------ | | 13| 82| context->igraph_errno = igraph_i_ret; \ | | 14| 82| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 82|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 82| YYABORT; \ | | ------------------ | | | | 784| 82|#define YYABORT goto yyabortlab | | ------------------ | | 16| 82| } \ | | 17| 2.30M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 2.30M] | | ------------------ ------------------ 1797| 2.30M| IGRAPH_YY_CHECK(igraph_i_dl_add_edge(from-1, to-1, context)); ------------------ | | 10| 2.30M| do { \ | | 11| 2.30M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 2.30M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 2.30M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.30M] | | | | ------------------ | | ------------------ | | 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.30M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 2.30M] | | ------------------ ------------------ 1798| 2.30M|} 1799| 2.30M|#line 1800 "/src/igraph/build/src/io/parsers/dl-parser.c" 1800| 2.30M| break; 1801| | 1802| 6.21M| case 42: ------------------ | Branch (1802:3): [True: 6.21M, False: 9.92M] ------------------ 1803| 6.21M|#line 209 "/src/igraph/src/io/dl-parser.y" 1804| 6.21M| { 1805| 6.21M| igraph_int_t val; 1806| 6.21M| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 6.21M| do { \ | | 11| 6.21M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 6.21M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 6.21M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 31, False: 6.21M] | | | | ------------------ | | ------------------ | | 13| 31| context->igraph_errno = igraph_i_ret; \ | | 14| 31| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 31|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 31| YYABORT; \ | | ------------------ | | | | 784| 31|#define YYABORT goto yyabortlab | | ------------------ | | 16| 31| } \ | | 17| 6.21M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 6.21M] | | ------------------ ------------------ 1807| 6.21M| igraph_dl_yyget_leng(scanner), 1808| 6.21M| &val)); 1809| 6.21M| (yyval.integer)=val; 1810| 6.21M|} 1811| 0|#line 1812 "/src/igraph/build/src/io/parsers/dl-parser.c" 1812| 0| break; 1813| | 1814| 114| case 43: ------------------ | Branch (1814:3): [True: 114, False: 16.1M] ------------------ 1815| 114|#line 217 "/src/igraph/src/io/dl-parser.y" 1816| 114| {} 1817| 114|#line 1818 "/src/igraph/build/src/io/parsers/dl-parser.c" 1818| 114| break; 1819| | 1820| 755| case 44: ------------------ | Branch (1820:3): [True: 755, False: 16.1M] ------------------ 1821| 755|#line 218 "/src/igraph/src/io/dl-parser.y" 1822| 755| {} 1823| 755|#line 1824 "/src/igraph/build/src/io/parsers/dl-parser.c" 1824| 755| break; 1825| | 1826| 196| case 45: ------------------ | Branch (1826:3): [True: 196, False: 16.1M] ------------------ 1827| 196|#line 221 "/src/igraph/src/io/dl-parser.y" 1828| 196| { 1829| 196| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w((yyvsp[-3].integer), (yyvsp[-2].integer), (yyvsp[-1].real), context)); } ------------------ | | 10| 196| do { \ | | 11| 196| igraph_error_t igraph_i_ret = (expr); \ | | 12| 196| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 196| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 196] | | | | ------------------ | | ------------------ | | 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| 196| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 196] | | ------------------ ------------------ 1830| 196|#line 1831 "/src/igraph/build/src/io/parsers/dl-parser.c" 1831| 196| break; 1832| | 1833| 559| case 46: ------------------ | Branch (1833:3): [True: 559, False: 16.1M] ------------------ 1834| 559|#line 223 "/src/igraph/src/io/dl-parser.y" 1835| 559| { 1836| 559| IGRAPH_YY_CHECK(igraph_i_dl_add_edge((yyvsp[-2].integer), (yyvsp[-1].integer), context)); ------------------ | | 10| 559| do { \ | | 11| 559| igraph_error_t igraph_i_ret = (expr); \ | | 12| 559| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 559| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 559] | | | | ------------------ | | ------------------ | | 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| 559| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 559] | | ------------------ ------------------ 1837| 559| } 1838| 559|#line 1839 "/src/igraph/build/src/io/parsers/dl-parser.c" 1839| 559| break; 1840| | 1841| 38.9k| case 47: ------------------ | Branch (1841:3): [True: 38.9k, False: 16.1M] ------------------ 1842| 38.9k|#line 227 "/src/igraph/src/io/dl-parser.y" 1843| 38.9k| { 1844| 38.9k| igraph_real_t val; 1845| 38.9k| IGRAPH_YY_CHECK(igraph_i_parse_real(igraph_dl_yyget_text(scanner), ------------------ | | 10| 38.9k| do { \ | | 11| 38.9k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 38.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 38.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 23, False: 38.9k] | | | | ------------------ | | ------------------ | | 13| 23| context->igraph_errno = igraph_i_ret; \ | | 14| 23| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 23|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 23| YYABORT; \ | | ------------------ | | | | 784| 23|#define YYABORT goto yyabortlab | | ------------------ | | 16| 23| } \ | | 17| 38.9k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 38.9k] | | ------------------ ------------------ 1846| 38.9k| igraph_dl_yyget_leng(scanner), 1847| 38.9k| &val)); 1848| 38.9k| (yyval.real)=val; 1849| 38.9k|} 1850| 0|#line 1851 "/src/igraph/build/src/io/parsers/dl-parser.c" 1851| 0| break; 1852| | 1853| 9.28k| case 48: ------------------ | Branch (1853:3): [True: 9.28k, False: 16.1M] ------------------ 1854| 9.28k|#line 235 "/src/igraph/src/io/dl-parser.y" 1855| 9.28k| { 1856| 9.28k| igraph_int_t trie_id; 1857| | 1858| | /* Copy label list to trie, if needed */ 1859| 9.28k| if (igraph_strvector_size(&context->labels) != 0) { ------------------ | Branch (1859:7): [True: 151, False: 9.13k] ------------------ 1860| 151| igraph_int_t i, id, n=igraph_strvector_size(&context->labels); 1861| 543k| for (i=0; itrie, igraph_strvector_get(&context->labels, i), &id)); ------------------ | | 10| 543k| do { \ | | 11| 543k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 543k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 543k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 543k] | | | | ------------------ | | ------------------ | | 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| 543k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 543k] | | ------------------ ------------------ 1863| 543k| } 1864| 151| igraph_strvector_clear(&context->labels); 1865| 151| } 1866| 9.28k| IGRAPH_YY_CHECK(igraph_trie_get_len(&context->trie, igraph_dl_yyget_text(scanner), ------------------ | | 10| 9.28k| do { \ | | 11| 9.28k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 9.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 9.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 9.28k] | | | | ------------------ | | ------------------ | | 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| 9.28k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 9.28k] | | ------------------ ------------------ 1867| 9.28k| igraph_dl_yyget_leng(scanner), &trie_id)); 1868| 9.28k| IGRAPH_ASSERT(0 <= trie_id && trie_id < IGRAPH_DL_MAX_VERTEX_COUNT); ------------------ | | 924| 9.28k| do { \ | | 925| 9.28k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 18.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 9.28k] | | | | | Branch (612:52): [True: 9.28k, False: 0] | | | | | Branch (612:52): [True: 9.28k, False: 0] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 9.28k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 9.28k] | | ------------------ ------------------ 1869| 9.28k| (yyval.integer) = trie_id; 1870| 9.28k| } 1871| 0|#line 1872 "/src/igraph/build/src/io/parsers/dl-parser.c" 1872| 0| break; 1873| | 1874| 109| case 49: ------------------ | Branch (1874:3): [True: 109, False: 16.1M] ------------------ 1875| 109|#line 254 "/src/igraph/src/io/dl-parser.y" 1876| 109| {} 1877| 109|#line 1878 "/src/igraph/build/src/io/parsers/dl-parser.c" 1878| 109| break; 1879| | 1880| 57| case 50: ------------------ | Branch (1880:3): [True: 57, False: 16.1M] ------------------ 1881| 57|#line 256 "/src/igraph/src/io/dl-parser.y" 1882| 57| {} 1883| 57|#line 1884 "/src/igraph/build/src/io/parsers/dl-parser.c" 1884| 57| break; 1885| | 1886| 1| case 51: ------------------ | Branch (1886:3): [True: 1, False: 16.1M] ------------------ 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| 35| case 52: ------------------ | Branch (1892:3): [True: 35, False: 16.1M] ------------------ 1893| 35|#line 258 "/src/igraph/src/io/dl-parser.y" 1894| 35| {} 1895| 35|#line 1896 "/src/igraph/build/src/io/parsers/dl-parser.c" 1896| 35| break; 1897| | 1898| 16| case 53: ------------------ | Branch (1898:3): [True: 16, False: 16.1M] ------------------ 1899| 16|#line 259 "/src/igraph/src/io/dl-parser.y" 1900| 16| {} 1901| 16|#line 1902 "/src/igraph/build/src/io/parsers/dl-parser.c" 1902| 16| break; 1903| | 1904| 0| case 54: ------------------ | Branch (1904:3): [True: 0, False: 16.1M] ------------------ 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| 282| case 55: ------------------ | Branch (1910:3): [True: 282, False: 16.1M] ------------------ 1911| 282|#line 263 "/src/igraph/src/io/dl-parser.y" 1912| 282| {} 1913| 282|#line 1914 "/src/igraph/build/src/io/parsers/dl-parser.c" 1914| 282| break; 1915| | 1916| 451| case 56: ------------------ | Branch (1916:3): [True: 451, False: 16.1M] ------------------ 1917| 451|#line 264 "/src/igraph/src/io/dl-parser.y" 1918| 451| {} 1919| 451|#line 1920 "/src/igraph/build/src/io/parsers/dl-parser.c" 1920| 451| break; 1921| | 1922| 451| case 57: ------------------ | Branch (1922:3): [True: 451, False: 16.1M] ------------------ 1923| 451|#line 267 "/src/igraph/src/io/dl-parser.y" 1924| 451| {} 1925| 451|#line 1926 "/src/igraph/build/src/io/parsers/dl-parser.c" 1926| 451| break; 1927| | 1928| 675| case 58: ------------------ | Branch (1928:3): [True: 675, False: 16.1M] ------------------ 1929| 675|#line 269 "/src/igraph/src/io/dl-parser.y" 1930| 675| { 1931| 675| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 675| do { \ | | 11| 675| igraph_error_t igraph_i_ret = (expr); \ | | 12| 675| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 675| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 9, False: 666] | | | | ------------------ | | ------------------ | | 13| 9| context->igraph_errno = igraph_i_ret; \ | | 14| 9| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 9|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 9| YYABORT; \ | | ------------------ | | | | 784| 9|#define YYABORT goto yyabortlab | | ------------------ | | 16| 9| } \ | | 17| 675| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 666] | | ------------------ ------------------ 1932| 675| igraph_dl_yyget_leng(scanner), 1933| 675| &context->from)); 1934| 666| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(context->from)); ------------------ | | 10| 666| do { \ | | 11| 666| igraph_error_t igraph_i_ret = (expr); \ | | 12| 666| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 666| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 52, False: 614] | | | | ------------------ | | ------------------ | | 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| 666| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 614] | | ------------------ ------------------ 1935| 666|} 1936| 614|#line 1937 "/src/igraph/build/src/io/parsers/dl-parser.c" 1937| 614| break; 1938| | 1939| 614| case 59: ------------------ | Branch (1939:3): [True: 614, False: 16.1M] ------------------ 1940| 614|#line 276 "/src/igraph/src/io/dl-parser.y" 1941| 614| {} 1942| 614|#line 1943 "/src/igraph/build/src/io/parsers/dl-parser.c" 1943| 614| break; 1944| | 1945| 1.52M| case 60: ------------------ | Branch (1945:3): [True: 1.52M, False: 14.6M] ------------------ 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: 55, False: 1.52M] | | | | ------------------ | | ------------------ | | 13| 55| context->igraph_errno = igraph_i_ret; \ | | 14| 55| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 55|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 55| YYABORT; \ | | ------------------ | | | | 784| 55|#define YYABORT goto yyabortlab | | ------------------ | | 16| 55| } \ | | 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: 233, False: 16.1M] ------------------ 1958| 233|#line 284 "/src/igraph/src/io/dl-parser.y" 1959| 233| {} 1960| 233|#line 1961 "/src/igraph/build/src/io/parsers/dl-parser.c" 1961| 233| break; 1962| | 1963| 3.54k| case 62: ------------------ | Branch (1963:3): [True: 3.54k, False: 16.1M] ------------------ 1964| 3.54k|#line 285 "/src/igraph/src/io/dl-parser.y" 1965| 3.54k| {} 1966| 3.54k|#line 1967 "/src/igraph/build/src/io/parsers/dl-parser.c" 1967| 3.54k| break; 1968| | 1969| 3.54k| case 63: ------------------ | Branch (1969:3): [True: 3.54k, False: 16.1M] ------------------ 1970| 3.54k|#line 288 "/src/igraph/src/io/dl-parser.y" 1971| 3.54k| { } 1972| 3.54k|#line 1973 "/src/igraph/build/src/io/parsers/dl-parser.c" 1973| 3.54k| break; 1974| | 1975| 3.72k| case 64: ------------------ | Branch (1975:3): [True: 3.72k, False: 16.1M] ------------------ 1976| 3.72k|#line 290 "/src/igraph/src/io/dl-parser.y" 1977| 3.72k| { 1978| 3.72k| context->from=(yyvsp[0].integer); 1979| 3.72k| } 1980| 3.72k|#line 1981 "/src/igraph/build/src/io/parsers/dl-parser.c" 1981| 3.72k| break; 1982| | 1983| 3.93k| case 66: ------------------ | Branch (1983:3): [True: 3.93k, False: 16.1M] ------------------ 1984| 3.93k|#line 294 "/src/igraph/src/io/dl-parser.y" 1985| 3.93k| { 1986| 3.93k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 3.93k| do { \ | | 11| 3.93k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.93k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 3.93k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.93k] | | | | ------------------ | | ------------------ | | 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.93k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 3.93k] | | ------------------ ------------------ 1987| 3.93k| context->from)); 1988| 3.93k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, (yyvsp[0].integer))); ------------------ | | 10| 3.93k| do { \ | | 11| 3.93k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.93k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 3.93k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.93k] | | | | ------------------ | | ------------------ | | 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.93k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 3.93k] | | ------------------ ------------------ 1989| 3.93k| } 1990| 3.93k|#line 1991 "/src/igraph/build/src/io/parsers/dl-parser.c" 1991| 3.93k| break; 1992| | 1993| | 1994| 3.93k|#line 1995 "/src/igraph/build/src/io/parsers/dl-parser.c" 1995| | 1996| 1.77M| default: break; ------------------ | Branch (1996:7): [True: 1.77M, False: 14.3M] ------------------ 1997| 16.1M| } 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| 16.1M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2010| | 2011| 16.1M| YYPOPSTACK (yylen); ------------------ | | 1361| 16.1M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2012| 16.1M| yylen = 0; 2013| 16.1M| YY_STACK_PRINT (yyss, yyssp); 2014| | 2015| 16.1M| *++yyvsp = yyval; 2016| 16.1M| *++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| 16.1M| { 2022| 16.1M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 532| 16.1M|#define YYNTOKENS 17 ------------------ 2023| 16.1M| const int yyi = yypgoto[yylhs] + *yyssp; 2024| 16.1M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 529| 27.1M|#define YYLAST 118 ------------------ | Branch (2024:16): [True: 10.9M, False: 5.14M] | Branch (2024:28): [True: 10.9M, False: 196] | Branch (2024:45): [True: 6.18M, False: 4.81M] ------------------ 2025| 16.1M| ? yytable[yyi] 2026| 16.1M| : yydefgoto[yylhs]); 2027| 16.1M| } 2028| | 2029| 16.1M| goto yynewstate; 2030| | 2031| | 2032| |/*--------------------------------------. 2033| || yyerrlab -- here on detecting error. | 2034| |`--------------------------------------*/ 2035| 832|yyerrlab: 2036| | /* Make sure we have latest lookahead translation. See comments at 2037| | user semantic actions for why this is necessary. */ 2038| 832| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 832|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 547| 1.66k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 832|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 832, False: 0] | | | Branch (547:18): [True: 832, False: 0] | | ------------------ ------------------ | Branch (2038:13): [True: 0, False: 832] ------------------ 2039| | 2040| | /* If not already recovering from an error, report this error. */ 2041| 832| if (!yyerrstatus) ------------------ | Branch (2041:7): [True: 832, False: 0] ------------------ 2042| 832| { 2043| 832| ++yynerrs; ------------------ | | 71| 832|#define yynerrs igraph_dl_yynerrs ------------------ 2044| |#if ! YYERROR_VERBOSE 2045| | yyerror (&yylloc, context, YY_("syntax error")); 2046| |#else 2047| 832|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2048| 832| yyssp, yytoken) 2049| 832| { 2050| 832| char const *yymsgp = YY_("syntax error"); ------------------ | | 334| 832|# define YY_(Msgid) Msgid ------------------ 2051| 832| int yysyntax_error_status; 2052| 832| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 2047| 832|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 2048| 832| yyssp, yytoken) ------------------ 2053| 832| if (yysyntax_error_status == 0) ------------------ | Branch (2053:13): [True: 832, False: 0] ------------------ 2054| 832| 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| 832| yyerror (&yylloc, context, yymsgp); ------------------ | | 69| 832|#define yyerror igraph_dl_yyerror ------------------ 2073| 832| if (yysyntax_error_status == 2) ------------------ | Branch (2073:13): [True: 0, False: 832] ------------------ 2074| 0| goto yyexhaustedlab; 2075| 832| } 2076| 832|# undef YYSYNTAX_ERROR 2077| 832|#endif 2078| 832| } 2079| | 2080| 832| yyerror_range[1] = yylloc; 2081| | 2082| 832| if (yyerrstatus == 3) ------------------ | Branch (2082:7): [True: 0, False: 832] ------------------ 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| 832| goto yyerrlab1; 2104| | 2105| | 2106| |/*---------------------------------------------------. 2107| || yyerrorlab -- error raised explicitly by YYERROR. | 2108| |`---------------------------------------------------*/ 2109| 832|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| 832|yyerrlab1: 2128| 832| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2129| | 2130| 832| for (;;) 2131| 8.02k| { 2132| 8.02k| yyn = yypact[yystate]; 2133| 8.02k| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 8.02k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 8.02k|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (2133:11): [True: 7.00k, False: 1.01k] ------------------ 2134| 7.00k| { 2135| 7.00k| yyn += YYTERROR; ------------------ | | 808| 7.00k|#define YYTERROR 1 ------------------ 2136| 7.00k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 529| 14.0k|#define YYLAST 118 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 808| 7.00k|#define YYTERROR 1 ------------------ | Branch (2136:15): [True: 7.00k, False: 0] | Branch (2136:27): [True: 7.00k, False: 0] | Branch (2136:44): [True: 0, False: 7.00k] ------------------ 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| 7.00k| } 2143| | 2144| | /* Pop the current state because it cannot handle the error token. */ 2145| 8.02k| if (yyssp == yyss) ------------------ | Branch (2145:11): [True: 832, False: 7.18k] ------------------ 2146| 832| YYABORT; ------------------ | | 784| 832|#define YYABORT goto yyabortlab ------------------ 2147| | 2148| 7.18k| yyerror_range[1] = *yylsp; 2149| 7.18k| yydestruct ("Error: popping", 2150| 7.18k| yystos[yystate], yyvsp, yylsp, context); 2151| 7.18k| YYPOPSTACK (1); ------------------ | | 1361| 7.18k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2152| 7.18k| yystate = *yyssp; 2153| 7.18k| YY_STACK_PRINT (yyss, yyssp); 2154| 7.18k| } 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| 820|yyacceptlab: 2177| 820| yyresult = 0; 2178| 820| goto yyreturn; 2179| | 2180| | 2181| |/*-----------------------------------. 2182| || yyabortlab -- YYABORT comes here. | 2183| |`-----------------------------------*/ 2184| 1.51k|yyabortlab: 2185| 1.51k| yyresult = 1; 2186| 1.51k| 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.33k|yyreturn: 2204| 2.33k| if (yychar != YYEMPTY) ------------------ | | 780| 2.33k|#define YYEMPTY (-2) ------------------ | Branch (2204:7): [True: 832, False: 1.50k] ------------------ 2205| 832| { 2206| | /* Make sure we have latest lookahead translation. See comments at 2207| | user semantic actions for why this is necessary. */ 2208| 832| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 832| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 832|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 832, False: 0] | | | Branch (547:18): [True: 832, False: 0] | | ------------------ ------------------ 2209| 832| yydestruct ("Cleanup: discarding lookahead", 2210| 832| yytoken, &yylval, &yylloc, context); 2211| 832| } 2212| | /* Do not reclaim the symbols of the rule whose action triggered 2213| | this YYABORT or YYACCEPT. */ 2214| 2.33k| YYPOPSTACK (yylen); ------------------ | | 1361| 2.33k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2215| 2.33k| YY_STACK_PRINT (yyss, yyssp); 2216| 9.52k| while (yyssp != yyss) ------------------ | Branch (2216:10): [True: 7.18k, False: 2.33k] ------------------ 2217| 7.18k| { 2218| 7.18k| yydestruct ("Cleanup: popping", 2219| 7.18k| yystos[+*yyssp], yyvsp, yylsp, context); 2220| 7.18k| YYPOPSTACK (1); ------------------ | | 1361| 7.18k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2221| 7.18k| } 2222| 2.33k|#ifndef yyoverflow 2223| 2.33k| if (yyss != yyssa) ------------------ | Branch (2223:7): [True: 0, False: 2.33k] ------------------ 2224| 0| YYSTACK_FREE (yyss); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2225| 2.33k|#endif 2226| 2.33k|#if YYERROR_VERBOSE 2227| 2.33k| if (yymsg != yymsgbuf) ------------------ | Branch (2227:7): [True: 0, False: 2.33k] ------------------ 2228| 0| YYSTACK_FREE (yymsg); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2229| 2.33k|#endif 2230| 2.33k| return yyresult; 2231| 0|} igraph_dl_yyerror: 2237| 1.46k| const char *s) { 2238| 1.46k| snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1, 2239| 1.46k| "Parse error in DL file, line %i (%s)", 2240| 1.46k| locp->first_line, s); 2241| 1.46k| return 0; 2242| 1.46k|} dl-parser.c:yysyntax_error: 1131| 832|{ 1132| 832| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1133| | /* Internationalized format string. */ 1134| 832| const char *yyformat = YY_NULLPTR; ------------------ | | 138| 832|# define YY_NULLPTR ((void*)0) ------------------ 1135| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1136| | one per "expected"). */ 1137| 832| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1138| | /* Actual size of YYARG. */ 1139| 832| int yycount = 0; 1140| | /* Cumulated lengths of YYARG. */ 1141| 832| YYPTRDIFF_T yysize = 0; ------------------ | | 285| 832|# 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| 832| if (yytoken != YYEMPTY) ------------------ | | 780| 832|#define YYEMPTY (-2) ------------------ | Branch (1166:7): [True: 832, False: 0] ------------------ 1167| 832| { 1168| 832| int yyn = yypact[+*yyssp]; 1169| 832| YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 285| 832|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 138| 832|# define YY_NULLPTR ((void*)0) ------------------ 1170| 832| yysize = yysize0; 1171| 832| yyarg[yycount++] = yytname[yytoken]; 1172| 832| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 832| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 832|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (1172:11): [True: 832, False: 0] ------------------ 1173| 832| { 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| 832| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1177:26): [True: 0, False: 832] ------------------ 1178| | /* Stay within bounds of both yycheck and yytname. */ 1179| 832| int yychecklim = YYLAST - yyn + 1; ------------------ | | 529| 832|#define YYLAST 118 ------------------ 1180| 832| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 832|#define YYNTOKENS 17 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 832|#define YYNTOKENS 17 ------------------ | Branch (1180:24): [True: 0, False: 832] ------------------ 1181| 832| int yyx; 1182| | 1183| 14.9k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1183:32): [True: 14.0k, False: 821] ------------------ 1184| 14.0k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 808| 15.4k|#define YYTERROR 1 ------------------ | Branch (1184:17): [True: 1.34k, False: 12.7k] | Branch (1184:46): [True: 1.34k, False: 0] ------------------ 1185| 0| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 637| 0| 0 ------------------ | Branch (1185:20): [True: 0, Folded] ------------------ 1186| 1.34k| { 1187| 1.34k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1187:21): [True: 11, False: 1.33k] ------------------ 1188| 11| { 1189| 11| yycount = 1; 1190| 11| yysize = yysize0; 1191| 11| break; 1192| 11| } 1193| 1.33k| yyarg[yycount++] = yytname[yyx]; 1194| 1.33k| { 1195| 1.33k| YYPTRDIFF_T yysize1 ------------------ | | 285| 1.33k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1196| 1.33k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 138| 1.33k|# define YY_NULLPTR ((void*)0) ------------------ 1197| 1.33k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 1.33k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 1.33k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 2.66k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 1.33k, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1197:23): [True: 1.33k, False: 0] | Branch (1197:44): [True: 1.33k, False: 0] ------------------ 1198| 1.33k| yysize = yysize1; 1199| 0| else 1200| 0| return 2; 1201| 1.33k| } 1202| 1.33k| } 1203| 832| } 1204| 832| } 1205| | 1206| 832| switch (yycount) 1207| 832| { 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: 832] ------------------ 1213| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1209| 0| case N: \ | | ------------------ | | | Branch (1209:7): [True: 0, False: 832] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1214| 11| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1209| 11| case N: \ | | ------------------ | | | Branch (1209:7): [True: 11, False: 821] | | ------------------ | | 1210| 11| yyformat = S; \ | | 1211| 11| break ------------------ 1215| 381| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1209| 381| case N: \ | | ------------------ | | | Branch (1209:7): [True: 381, False: 451] | | ------------------ | | 1210| 381| yyformat = S; \ | | 1211| 381| break ------------------ 1216| 413| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1209| 413| case N: \ | | ------------------ | | | Branch (1209:7): [True: 413, False: 419] | | ------------------ | | 1210| 413| yyformat = S; \ | | 1211| 413| break ------------------ 1217| 27| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1209| 27| case N: \ | | ------------------ | | | Branch (1209:7): [True: 27, False: 805] | | ------------------ | | 1210| 27| yyformat = S; \ | | 1211| 27| break ------------------ 1218| 832| 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: 832] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1219| 832|# undef YYCASE_ 1220| 832| } 1221| | 1222| 832| { 1223| | /* Don't count the "%s"s in the final size, but reserve room for 1224| | the terminator. */ 1225| 832| YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 285| 832|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 1035| 832|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 832|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1226| 832| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 832|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 832| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 1.66k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 832, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1226:9): [True: 832, False: 0] | Branch (1226:30): [True: 832, False: 0] ------------------ 1227| 832| yysize = yysize1; 1228| 0| else 1229| 0| return 2; 1230| 832| } 1231| | 1232| 832| if (*yymsg_alloc < yysize) ------------------ | Branch (1232:7): [True: 0, False: 832] ------------------ 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| 832| { 1245| 832| char *yyp = *yymsg; 1246| 832| int yyi = 0; 1247| 35.4k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1247:12): [True: 34.6k, False: 832] ------------------ 1248| 34.6k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1248:11): [True: 2.12k, False: 32.5k] | Branch (1248:26): [True: 2.12k, False: 0] | Branch (1248:48): [True: 2.12k, False: 0] ------------------ 1249| 2.12k| { 1250| 2.12k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1251| 2.12k| yyformat += 2; 1252| 2.12k| } 1253| 32.5k| else 1254| 32.5k| { 1255| 32.5k| ++yyp; 1256| 32.5k| ++yyformat; 1257| 32.5k| } 1258| 832| } 1259| 832| return 0; 1260| 832|} dl-parser.c:yytnamerr: 1079| 4.28k|{ 1080| 4.28k| if (*yystr == '"') ------------------ | Branch (1080:7): [True: 3.08k, False: 1.19k] ------------------ 1081| 3.08k| { 1082| 3.08k| YYPTRDIFF_T yyn = 0; ------------------ | | 285| 3.08k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1083| 3.08k| char const *yyp = yystr; 1084| | 1085| 3.08k| for (;;) 1086| 26.4k| switch (*++yyp) 1087| 26.4k| { 1088| 0| case '\'': ------------------ | Branch (1088:11): [True: 0, False: 26.4k] ------------------ 1089| 0| case ',': ------------------ | Branch (1089:11): [True: 0, False: 26.4k] ------------------ 1090| 0| goto do_not_strip_quotes; 1091| | 1092| 0| case '\\': ------------------ | Branch (1092:11): [True: 0, False: 26.4k] ------------------ 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| 23.3k| default: ------------------ | Branch (1099:11): [True: 23.3k, False: 3.08k] ------------------ 1100| 23.3k| if (yyres) ------------------ | Branch (1100:17): [True: 11.5k, False: 11.8k] ------------------ 1101| 11.5k| yyres[yyn] = *yyp; 1102| 23.3k| yyn++; 1103| 23.3k| break; 1104| | 1105| 3.08k| case '"': ------------------ | Branch (1105:11): [True: 3.08k, False: 23.3k] ------------------ 1106| 3.08k| if (yyres) ------------------ | Branch (1106:17): [True: 1.52k, False: 1.56k] ------------------ 1107| 1.52k| yyres[yyn] = '\0'; 1108| 3.08k| return yyn; 1109| 26.4k| } 1110| 0| do_not_strip_quotes: ; 1111| 0| } 1112| | 1113| 1.19k| if (yyres) ------------------ | Branch (1113:7): [True: 593, False: 604] ------------------ 1114| 593| return yystpcpy (yyres, yystr) - yyres; 1115| 604| else 1116| 604| return yystrlen (yystr); ------------------ | | 1035| 604|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 604|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1117| 1.19k|} dl-parser.c:yystpcpy: 1057| 593|{ 1058| 593| char *yyd = yydest; 1059| 593| const char *yys = yysrc; 1060| | 1061| 3.15k| while ((*yyd++ = *yys++) != '\0') ------------------ | Branch (1061:10): [True: 2.56k, False: 593] ------------------ 1062| 2.56k| continue; 1063| | 1064| 593| return yyd - 1; 1065| 593|} dl-parser.c:yydestruct: 1269| 15.2k|{ 1270| 15.2k| YYUSE (yyvaluep); ------------------ | | 356| 15.2k|# define YYUSE(E) ((void) (E)) ------------------ 1271| 15.2k| YYUSE (yylocationp); ------------------ | | 356| 15.2k|# define YYUSE(E) ((void) (E)) ------------------ 1272| 15.2k| YYUSE (context); ------------------ | | 356| 15.2k|# define YYUSE(E) ((void) (E)) ------------------ 1273| 15.2k| if (!yymsg) ------------------ | Branch (1273:7): [True: 0, False: 15.2k] ------------------ 1274| 0| yymsg = "Deleting"; 1275| 15.2k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1276| | 1277| 15.2k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1278| 15.2k| YYUSE (yytype); ------------------ | | 356| 15.2k|# define YYUSE(E) ((void) (E)) ------------------ 1279| 15.2k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1280| 15.2k|} dl-parser.c:igraph_i_dl_add_str: 2245| 1.74M| igraph_i_dl_parsedata_t *context) { 2246| 1.74M| IGRAPH_CHECK(igraph_strvector_push_back_len(&context->labels, newstr, length)); ------------------ | | 656| 1.74M| do { \ | | 657| 1.74M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.74M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.74M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.74M] | | | | ------------------ | | ------------------ | | 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.74M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.74M] | | ------------------ ------------------ 2247| 1.74M| return IGRAPH_SUCCESS; 2248| 1.74M|} dl-parser.c:igraph_i_dl_add_edge: 2251| 2.34M| 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.34M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, from)); ------------------ | | 656| 2.34M| do { \ | | 657| 2.34M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.34M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.34M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.34M] | | | | ------------------ | | ------------------ | | 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.34M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.34M] | | ------------------ ------------------ 2255| 2.34M| IGRAPH_CHECK(igraph_vector_int_push_back(&context->edges, to)); ------------------ | | 656| 2.34M| do { \ | | 657| 2.34M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.34M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.34M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.34M] | | | | ------------------ | | ------------------ | | 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.34M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.34M] | | ------------------ ------------------ 2256| 2.34M| return IGRAPH_SUCCESS; 2257| 2.34M|} dl-parser.c:igraph_i_dl_add_edge_w: 2261| 38.6k| igraph_i_dl_parsedata_t *context) { 2262| 38.6k| igraph_int_t n=igraph_vector_size(&context->weights); 2263| 38.6k| igraph_int_t n2=igraph_vector_int_size(&context->edges)/2; 2264| 38.6k| if (n != n2) { ------------------ | Branch (2264:7): [True: 36.8k, False: 1.75k] ------------------ 2265| 36.8k| IGRAPH_CHECK(igraph_vector_resize(&context->weights, n2)); ------------------ | | 656| 36.8k| do { \ | | 657| 36.8k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 36.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 36.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 36.8k] | | | | ------------------ | | ------------------ | | 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| 36.8k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 36.8k] | | ------------------ ------------------ 2266| 2.33M| for (; nweights)[n]=IGRAPH_NAN; ------------------ | | 60| 2.29M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context->weights)[n]=IGRAPH_NAN; ------------------ | | 138| 2.29M|#define IGRAPH_NAN ((double)NAN) ------------------ 2268| 2.29M| } 2269| 36.8k| } 2270| 38.6k| IGRAPH_CHECK(igraph_i_dl_add_edge(from, to, context)); ------------------ | | 656| 38.6k| do { \ | | 657| 38.6k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 38.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 38.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 38.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| 38.6k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 38.6k] | | ------------------ ------------------ 2271| 38.6k| IGRAPH_CHECK(igraph_vector_push_back(&context->weights, weight)); ------------------ | | 656| 38.6k| do { \ | | 657| 38.6k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 38.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 38.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 38.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| 38.6k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 38.6k] | | ------------------ ------------------ 2272| 38.6k| return IGRAPH_SUCCESS; 2273| 38.6k|} dl-parser.c:igraph_i_dl_check_vid: 2277| 6.21M|static igraph_error_t igraph_i_dl_check_vid(igraph_int_t dl_vid) { 2278| 6.21M| if (dl_vid < 1) { ------------------ | Branch (2278:9): [True: 326, False: 6.21M] ------------------ 2279| 326| IGRAPH_ERRORF("Invalid vertex index in DL file: %" IGRAPH_PRId ".", ------------------ | | 464| 326| do { \ | | 465| 326| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 326| igraph_errno, __VA_ARGS__) ; \ | | 467| 326| return igraph_errno; \ | | 468| 326| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 2280| 326| IGRAPH_EINVAL, dl_vid); 2281| 326| } 2282| 6.21M| if (dl_vid > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 6.21M|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (2282:9): [True: 245, False: 6.21M] ------------------ 2283| 245| IGRAPH_ERRORF("Vertex index too large in DL file: %" IGRAPH_PRId ".", ------------------ | | 464| 245| do { \ | | 465| 245| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 245| igraph_errno, __VA_ARGS__) ; \ | | 467| 245| return igraph_errno; \ | | 468| 245| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 2284| 245| IGRAPH_EINVAL, dl_vid); 2285| 245| } 2286| 6.21M| return IGRAPH_SUCCESS; 2287| 6.21M|} LLVMFuzzerTestOneInput: 25| 2.33k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 26| | 27| 2.33k| igraph_set_error_handler(igraph_error_handler_ignore); 28| 2.33k| igraph_set_warning_handler(igraph_warning_handler_ignore); 29| | 30| | // Turn on attribute handling 31| 2.33k| igraph_set_attribute_table(&igraph_cattribute_table); 32| | 33| | // Read input file 34| 2.33k| FILE *ifile = fmemopen((void*) data, size, "r"); 35| 2.33k| if (!ifile) { ------------------ | Branch (35:9): [True: 0, False: 2.33k] ------------------ 36| 0| return 0; 37| 0| } 38| | 39| | // Do the fuzzing 40| 2.33k| igraph_t g; 41| 2.33k| if (igraph_read_graph_dl(&g, ifile, IGRAPH_DIRECTED) == IGRAPH_SUCCESS) { ------------------ | Branch (41:9): [True: 496, False: 1.84k] ------------------ 42| | // Clean up 43| 496| igraph_destroy(&g); 44| 496| } 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.33k| fclose(ifile); 50| | 51| 2.33k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY); ------------------ | | 924| 2.33k| do { \ | | 925| 2.33k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | ------------------ | | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__ | | ------------------ | | 927| 0| } \ | | 928| 2.33k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.33k] | | ------------------ ------------------ 52| | 53| 2.33k| return 0; 54| 2.33k|} igraph_error: 210| 2.98k| igraph_error_t igraph_errno) { 211| | 212| 2.98k| if (igraph_i_error_handler) { ------------------ | Branch (212:9): [True: 2.98k, False: 0] ------------------ 213| 2.98k| igraph_i_error_handler(reason, file, line, igraph_errno); 214| 2.98k|#ifndef USING_R 215| 2.98k| } else { 216| 0| igraph_error_handler_abort(reason, file, line, igraph_errno); 217| 0|#endif 218| 0| } 219| 2.98k| return igraph_errno; 220| 2.98k|} igraph_errorf: 240| 624| igraph_error_t igraph_errno, ...) { 241| 624| va_list ap; 242| 624| va_start(ap, igraph_errno); 243| 624| vsnprintf(igraph_i_errormsg_buffer, 244| 624| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap); 245| | va_end(ap); 246| 624| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno); 247| 624|} igraph_error_handler_ignore: 266| 2.98k| int line, igraph_error_t igraph_errno) { 267| 2.98k| IGRAPH_UNUSED(reason); ------------------ | | 30| 2.98k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 268| 2.98k| IGRAPH_UNUSED(file); ------------------ | | 30| 2.98k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 269| 2.98k| IGRAPH_UNUSED(line); ------------------ | | 30| 2.98k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 270| 2.98k| IGRAPH_UNUSED(igraph_errno); ------------------ | | 30| 2.98k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 271| | 272| 2.98k| IGRAPH_FINALLY_FREE(); 273| 2.98k|} igraph_set_error_handler: 298| 2.33k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) { 299| 2.33k| igraph_error_handler_t *previous_handler = igraph_i_error_handler; 300| 2.33k| igraph_i_error_handler = new_handler; 301| 2.33k| return previous_handler; 302| 2.33k|} IGRAPH_FINALLY_REAL: 320| 88.4k|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) { 321| 88.4k| int no = igraph_i_finally_stack_size; 322| 88.4k| if (no < 0) { ------------------ | Branch (322:9): [True: 0, False: 88.4k] ------------------ 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| 88.4k| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) { ------------------ | Branch (327:9): [True: 0, False: 88.4k] ------------------ 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| 88.4k| igraph_i_finally_stack[no].ptr = ptr; 333| 88.4k| igraph_i_finally_stack[no].func = func; 334| 88.4k| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level; 335| 88.4k| igraph_i_finally_stack_size++; 336| 88.4k|} IGRAPH_FINALLY_CLEAN: 338| 28.3k|void IGRAPH_FINALLY_CLEAN(int minus) { 339| 28.3k| igraph_i_finally_stack_size -= minus; 340| 28.3k| if (igraph_i_finally_stack_size < 0) { ------------------ | Branch (340:9): [True: 0, False: 28.3k] ------------------ 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| 28.3k|} IGRAPH_FINALLY_FREE: 348| 2.98k|void IGRAPH_FINALLY_FREE(void) { 349| 12.7k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) { ------------------ | Branch (349:12): [True: 10.5k, False: 2.16k] ------------------ 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: 823, False: 9.77k] ------------------ 353| 823| break; 354| 823| } 355| 9.77k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr); 356| 9.77k| } 357| 2.98k|} IGRAPH_FINALLY_STACK_SIZE: 359| 2.33k|int IGRAPH_FINALLY_STACK_SIZE(void) { 360| 2.33k| return igraph_i_finally_stack_size; 361| 2.33k|} IGRAPH_FINALLY_ENTER: 377| 556k|void IGRAPH_FINALLY_ENTER(void) { 378| 556k| int no = igraph_i_finally_stack_size; 379| | /* Level indices must always be in increasing order in the finally stack */ 380| 556k| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) { ------------------ | Branch (380:9): [True: 556k, False: 0] | Branch (380:19): [True: 0, False: 556k] ------------------ 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| 556k| igraph_i_finally_stack_level++; 386| 556k|} IGRAPH_FINALLY_EXIT: 399| 556k|void IGRAPH_FINALLY_EXIT(void) { 400| 556k| igraph_i_finally_stack_level--; 401| 556k| if (igraph_i_finally_stack_level < 0) { ------------------ | Branch (401:9): [True: 0, False: 556k] ------------------ 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| 556k|} igraph_warning_handler_ignore: 424| 296|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) { 425| 296| IGRAPH_UNUSED(reason); ------------------ | | 30| 296|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 426| 296| IGRAPH_UNUSED(file); ------------------ | | 30| 296|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 427| 296| IGRAPH_UNUSED(line); ------------------ | | 30| 296|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 428| 296|} igraph_warning: 463| 296|void igraph_warning(const char *reason, const char *file, int line) { 464| | 465| 296| if (igraph_i_warning_handler) { ------------------ | Branch (465:9): [True: 296, False: 0] ------------------ 466| 296| igraph_i_warning_handler(reason, file, line); 467| 296|#ifndef USING_R 468| 296| } else { 469| 0| igraph_warning_handler_print(reason, file, line); 470| 0|#endif 471| 0| } 472| 296|} igraph_set_warning_handler: 514| 2.33k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) { 515| 2.33k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler; 516| 2.33k| igraph_i_warning_handler = new_handler; 517| 2.33k| return previous_handler; 518| 2.33k|} igraph_free: 62| 1.49k|void igraph_free(void *ptr) { 63| | IGRAPH_FREE(ptr); ------------------ | | 36| 1.49k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 64| 1.49k|} igraph_strvector_init: 71| 16.0k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_int_t size) { 72| | 73| 16.0k| sv->stor_begin = IGRAPH_CALLOC(size, const char *); ------------------ | | 33| 16.0k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 32.0k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 16.0k, False: 0] | | | | | Branch (31:24): [True: 16.0k, False: 0] | | | | | Branch (31:66): [True: 8.65k, False: 7.36k] | | | | ------------------ | | ------------------ ------------------ 74| 16.0k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector."); ------------------ | | 709| 16.0k| do { \ | | 710| 16.0k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 16.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 16.0k] | | | | ------------------ | | ------------------ | | 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| 16.0k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 16.0k] | | ------------------ ------------------ 75| | 76| 16.0k| sv->stor_end = sv->stor_begin + size; 77| 16.0k| sv->end = sv->stor_end; 78| | 79| 16.0k| return IGRAPH_SUCCESS; 80| 16.0k|} igraph_strvector_destroy: 95| 16.0k|void igraph_strvector_destroy(igraph_strvector_t *sv) { 96| 16.0k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 16.0k| do { \ | | 925| 16.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 16.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 16.0k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 16.0k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 16.0k] | | ------------------ ------------------ 97| 16.0k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 16.0k| do { \ | | 925| 16.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 16.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 16.0k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 16.0k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 16.0k] | | ------------------ ------------------ 98| 2.45M| for (const char **ptr = sv->stor_begin; ptr < sv->end; ptr++) { ------------------ | Branch (98:45): [True: 2.43M, False: 16.0k] ------------------ 99| 2.43M| IGRAPH_FREE(*ptr); ------------------ | | 36| 2.43M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 100| 2.43M| } 101| | IGRAPH_FREE(sv->stor_begin); ------------------ | | 36| 16.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 102| 16.0k|} igraph_strvector_get: 117| 7.46M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_int_t idx) { 118| 7.46M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 7.46M| do { \ | | 925| 7.46M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 7.46M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.46M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 7.46M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 7.46M] | | ------------------ ------------------ 119| 7.46M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 7.46M| do { \ | | 925| 7.46M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 7.46M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.46M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 7.46M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 7.46M] | | ------------------ ------------------ 120| 7.46M| return sv->stor_begin[idx] ? sv->stor_begin[idx] : ""; ------------------ | Branch (120:12): [True: 7.46M, False: 0] ------------------ 121| 7.46M|} igraph_strvector_set: 141| 19.8k| const char *value) { 142| 19.8k| return igraph_strvector_set_len(sv, idx, value, strlen(value)); 143| 19.8k|} igraph_strvector_set_len: 163| 19.8k| const char *value, size_t len) { 164| 19.8k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 19.8k| do { \ | | 925| 19.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 19.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 19.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 19.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 19.8k] | | ------------------ ------------------ 165| 19.8k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 19.8k| do { \ | | 925| 19.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 19.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 19.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 19.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 19.8k] | | ------------------ ------------------ 166| | 167| 19.8k| if (sv->stor_begin[idx] == NULL) { ------------------ | Branch (167:9): [True: 12.6k, False: 7.23k] ------------------ 168| 12.6k| sv->stor_begin[idx] = strndup(value, len); 169| 12.6k| IGRAPH_CHECK_OOM(sv->stor_begin[idx], "Cannot reserve space for new item in string vector."); ------------------ | | 709| 12.6k| do { \ | | 710| 12.6k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 12.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 12.6k] | | | | ------------------ | | ------------------ | | 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| 12.6k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 12.6k] | | ------------------ ------------------ 170| 12.6k| } else { 171| 7.23k| char *tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char); ------------------ | | 35| 7.23k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 14.4k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 7.23k, False: 0] | | | | | Branch (31:24): [True: 7.23k, False: 0] | | | | | Branch (31:66): [True: 7.23k, False: 0] | | | | ------------------ | | ------------------ ------------------ 172| 7.23k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector."); ------------------ | | 709| 7.23k| do { \ | | 710| 7.23k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 7.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.23k] | | | | ------------------ | | ------------------ | | 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| 7.23k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 7.23k] | | ------------------ ------------------ 173| | 174| 7.23k| memcpy(tmp, value, len * sizeof(char)); 175| 7.23k| tmp[len] = '\0'; 176| 7.23k| sv->stor_begin[idx] = tmp; 177| 7.23k| } 178| | 179| 19.8k| return IGRAPH_SUCCESS; 180| 19.8k|} igraph_strvector_append: 300| 212| const igraph_strvector_t *from) { 301| 212| const igraph_int_t to_size = igraph_strvector_size(to); 302| 212| const igraph_int_t from_size = igraph_strvector_size(from); 303| 212| const igraph_int_t to_capacity = igraph_strvector_capacity(to); 304| 212| igraph_int_t new_to_size; 305| 212| igraph_bool_t error = false; 306| 212| const char *tmp; 307| | 308| 212| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 212| do { \ | | 48| 212| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 212| igraph_int_t _safe_sum; \ | | 50| 212| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 212] | | ------------------ | | 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| 212| *(res) = _safe_sum; \ | | 54| 212| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 212] | | ------------------ ------------------ 309| | 310| 212| if (to_capacity < new_to_size) { ------------------ | Branch (310:9): [True: 212, False: 0] ------------------ 311| 212| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 212|# 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| 212|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (311:40): [True: 212, False: 0] ------------------ 312| 212| if (new_to_capacity < new_to_size) { ------------------ | Branch (312:13): [True: 212, False: 0] ------------------ 313| 212| new_to_capacity = new_to_size; 314| 212| } 315| 212| IGRAPH_CHECK(igraph_strvector_reserve(to, new_to_capacity)); ------------------ | | 656| 212| do { \ | | 657| 212| igraph_error_t igraph_i_ret = (expr); \ | | 658| 212| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 212| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 212] | | | | ------------------ | | ------------------ | | 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| 212| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 212] | | ------------------ ------------------ 316| 212| } 317| | 318| 1.18M| for (igraph_int_t i = 0; i < from_size; i++) { ------------------ | Branch (318:30): [True: 1.18M, False: 212] ------------------ 319| 1.18M| if (from->stor_begin[i] == NULL || from->stor_begin[i][0] == '\0') { ------------------ | Branch (319:13): [True: 0, False: 1.18M] | Branch (319:44): [True: 0, False: 1.18M] ------------------ 320| | /* Represent empty strings as NULL. */ 321| 0| tmp = NULL; 322| 1.18M| } else { 323| 1.18M| tmp = strdup(from->stor_begin[i]); 324| 1.18M| if (tmp == NULL) { ------------------ | Branch (324:17): [True: 0, False: 1.18M] ------------------ 325| 0| error = true; 326| 0| break; 327| 0| } 328| 1.18M| } 329| 1.18M| *(to->end) = tmp; 330| 1.18M| to->end++; 331| 1.18M| } 332| | 333| 212| if (error) { ------------------ | Branch (333:9): [True: 0, False: 212] ------------------ 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| 212| return IGRAPH_SUCCESS; 339| 212|} igraph_strvector_clear: 393| 326|void igraph_strvector_clear(igraph_strvector_t *sv) { 394| 326| igraph_int_t n = igraph_strvector_size(sv); 395| | 396| 543k| for (igraph_int_t i = 0; i < n; i++) { ------------------ | Branch (396:30): [True: 543k, False: 326] ------------------ 397| | IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 36| 543k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 398| 543k| } 399| 326| sv->end = sv->stor_begin; 400| 326|} igraph_strvector_resize: 419| 530k|igraph_error_t igraph_strvector_resize(igraph_strvector_t *sv, igraph_int_t newsize) { 420| 530k| igraph_int_t toadd = newsize - igraph_strvector_size(sv); 421| 530k| igraph_int_t oldsize = igraph_strvector_size(sv); 422| | 423| 530k| if (newsize < oldsize) { ------------------ | Branch (423:9): [True: 530k, False: 138] ------------------ 424| 1.06M| for (igraph_int_t i = newsize; i < oldsize; i++) { ------------------ | Branch (424:40): [True: 530k, False: 530k] ------------------ 425| 530k| IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 36| 530k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 426| 530k| } 427| 530k| sv->end = sv->stor_begin + newsize; 428| 530k| } else if (newsize > oldsize) { ------------------ | Branch (428:16): [True: 0, False: 138] ------------------ 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| 530k| return IGRAPH_SUCCESS; 435| 530k|} igraph_strvector_capacity: 448| 8.77k|igraph_int_t igraph_strvector_capacity(const igraph_strvector_t *sv) { 449| 8.77k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 8.77k| do { \ | | 925| 8.77k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 8.77k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.77k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.77k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.77k] | | ------------------ ------------------ 450| 8.77k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 8.77k| do { \ | | 925| 8.77k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 8.77k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.77k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.77k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.77k] | | ------------------ ------------------ 451| 8.77k| return sv->stor_end - sv->stor_begin; 452| 8.77k|} igraph_strvector_reserve: 481| 8.56k|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_int_t capacity) { 482| 8.56k| igraph_int_t current_capacity = igraph_strvector_capacity(sv); 483| | 484| 8.56k| if (capacity <= current_capacity) { ------------------ | Branch (484:9): [True: 0, False: 8.56k] ------------------ 485| 0| return IGRAPH_SUCCESS; 486| 0| } 487| | 488| 8.56k| const char **tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, const char *); ------------------ | | 35| 8.56k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 17.1k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 8.56k, False: 0] | | | | | Branch (31:24): [True: 8.56k, False: 0] | | | | | Branch (31:66): [True: 8.56k, False: 0] | | | | ------------------ | | ------------------ ------------------ 489| 8.56k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector."); ------------------ | | 709| 8.56k| do { \ | | 710| 8.56k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 8.56k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.56k] | | | | ------------------ | | ------------------ | | 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.56k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 8.56k] | | ------------------ ------------------ 490| | 491| 8.56k| sv->end = tmp + (sv->end - sv->stor_begin); 492| 8.56k| sv->stor_begin = tmp; 493| 8.56k| sv->stor_end = sv->stor_begin + capacity; 494| | 495| 8.56k| return IGRAPH_SUCCESS; 496| 8.56k|} 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| 564k|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) { 581| 564k| IGRAPH_CHECK(strvector_expand_if_full(sv)); ------------------ | | 656| 564k| do { \ | | 657| 564k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 564k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 564k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 564k] | | | | ------------------ | | ------------------ | | 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| 564k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 564k] | | ------------------ ------------------ 582| 564k| const char *tmp = strdup(value); 583| 564k| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector."); ------------------ | | 709| 564k| do { \ | | 710| 564k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 564k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 564k] | | | | ------------------ | | ------------------ | | 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| 564k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 564k] | | ------------------ ------------------ 584| 564k| *sv->end = tmp; 585| 564k| sv->end++; 586| | 587| 564k| return IGRAPH_SUCCESS; 588| 564k|} igraph_strvector_push_back_len: 606| 1.74M| const char *value, size_t len) { 607| | 608| 1.74M| IGRAPH_CHECK(strvector_expand_if_full(sv)); ------------------ | | 656| 1.74M| do { \ | | 657| 1.74M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.74M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.74M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.74M] | | | | ------------------ | | ------------------ | | 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.74M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.74M] | | ------------------ ------------------ 609| 1.74M| const char *tmp = strndup(value, len); 610| 1.74M| IGRAPH_CHECK_OOM(tmp, "Insufficient memory to push to string vector."); ------------------ | | 709| 1.74M| do { \ | | 710| 1.74M| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.74M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.74M] | | | | ------------------ | | ------------------ | | 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.74M| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.74M] | | ------------------ ------------------ 611| 1.74M| *sv->end = tmp; 612| 1.74M| sv->end++; 613| | 614| 1.74M| return IGRAPH_SUCCESS; 615| 1.74M|} igraph_strvector_update: 698| 175|) { 699| 175| igraph_strvector_clear(to); 700| 175| IGRAPH_CHECK(igraph_strvector_append(to, from)); ------------------ | | 656| 175| do { \ | | 657| 175| igraph_error_t igraph_i_ret = (expr); \ | | 658| 175| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 175| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 175] | | | | ------------------ | | ------------------ | | 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| 175| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 175] | | ------------------ ------------------ 701| 175| return IGRAPH_SUCCESS; 702| 175|} strvector.c:strvector_expand_if_full: 548| 2.31M|static igraph_error_t strvector_expand_if_full(igraph_strvector_t *sv) { 549| 2.31M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 2.31M| do { \ | | 925| 2.31M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.31M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.31M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.31M] | | ------------------ ------------------ 550| 2.31M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 2.31M| do { \ | | 925| 2.31M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.31M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.31M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.31M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.31M] | | ------------------ ------------------ 551| | 552| 2.31M| if (sv->stor_end == sv->end) { ------------------ | Branch (552:9): [True: 8.35k, False: 2.30M] ------------------ 553| 8.35k| igraph_int_t old_size = igraph_strvector_size(sv); 554| 8.35k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 8.35k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 8.35k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (554:33): [True: 8.35k, False: 0] ------------------ 555| 8.35k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 8.35k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (555:13): [True: 0, False: 8.35k] ------------------ 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| 8.35k| if (new_size == 0) { ------------------ | Branch (558:13): [True: 1.04k, False: 7.31k] ------------------ 559| 1.04k| new_size = 1; 560| 1.04k| } 561| 8.35k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size)); ------------------ | | 656| 8.35k| do { \ | | 657| 8.35k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 8.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 8.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.35k] | | | | ------------------ | | ------------------ | | 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.35k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 8.35k] | | ------------------ ------------------ 562| 8.35k| } 563| | 564| 2.31M| return IGRAPH_SUCCESS; 565| 2.31M|} igraph_trie_init: 61| 2.33k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) { 62| 2.33k| t->maxvalue = -1; 63| 2.33k| t->storekeys = storekeys; 64| 2.33k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node)); ------------------ | | 656| 2.33k| do { \ | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 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.33k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.33k] | | ------------------ ------------------ 65| 2.33k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node); ------------------ | | 603| 2.33k| do { \ | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | 607| 2.33k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.33k] | | ------------------ | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.33k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.33k] | | ------------------ ------------------ 66| 2.33k| if (storekeys) { ------------------ | Branch (66:9): [True: 2.33k, False: 0] ------------------ 67| 2.33k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0)); ------------------ | | 656| 2.33k| do { \ | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 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.33k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.33k] | | ------------------ ------------------ 68| 2.33k| } 69| | 70| 2.33k| IGRAPH_FINALLY_CLEAN(1); 71| 2.33k| return IGRAPH_SUCCESS; 72| 2.33k|} igraph_trie_destroy: 102| 2.33k|void igraph_trie_destroy(igraph_trie_t *t) { 103| 2.33k| if (t->storekeys) { ------------------ | Branch (103:9): [True: 2.33k, False: 0] ------------------ 104| 2.33k| igraph_strvector_destroy(&t->keys); 105| 2.33k| } 106| 2.33k| igraph_i_trie_destroy_node(&t->node); 107| 2.33k|} igraph_trie_get: 298| 552k|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_int_t *id) { 299| 552k| assert(key != NULL); ------------------ | Branch (299:5): [True: 0, False: 552k] | Branch (299:5): [True: 552k, False: 0] ------------------ 300| | 301| 552k| if (*key == '\0') { ------------------ | Branch (301:9): [True: 0, False: 552k] ------------------ 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| 552k| if (!t->storekeys) { ------------------ | Branch (305:9): [True: 0, False: 552k] ------------------ 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| 552k| } else { 311| 552k| igraph_error_t ret; 312| | 313| 552k| IGRAPH_FINALLY_ENTER(); 314| | /* Add it to the string vector first, we can undo this later */ 315| 552k| ret = igraph_strvector_push_back(&t->keys, key); 316| 552k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (316:13): [True: 0, False: 552k] ------------------ 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| 552k| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id); 321| 552k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (321:13): [True: 0, False: 552k] ------------------ 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| 552k| if (*id > t->maxvalue) { ------------------ | Branch (328:13): [True: 21.7k, False: 530k] ------------------ 329| 21.7k| t->maxvalue = *id; 330| 530k| } else { 331| 530k| igraph_strvector_resize(&t->keys, igraph_strvector_size(&t->keys) - 1); /* shrinks, error safe */ 332| 530k| } 333| 552k| IGRAPH_FINALLY_EXIT(); 334| 552k| } 335| | 336| 552k| return IGRAPH_SUCCESS; 337| 552k|} igraph_trie_get_len: 357| 9.28k| igraph_int_t *id) { 358| | 359| 9.28k| char *tmp = strndup(key, length); 360| 9.28k| IGRAPH_CHECK_OOM(tmp, "Cannot get from trie."); ------------------ | | 709| 9.28k| do { \ | | 710| 9.28k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 9.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 9.28k] | | | | ------------------ | | ------------------ | | 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| 9.28k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 9.28k] | | ------------------ ------------------ 361| 9.28k| IGRAPH_FINALLY(igraph_free, tmp); ------------------ | | 603| 9.28k| do { \ | | 604| 9.28k| /* the following branch makes the compiler check the compatibility of \ | | 605| 9.28k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 9.28k| * incorrect destructor function with the pointer */ \ | | 607| 9.28k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 9.28k] | | ------------------ | | 608| 9.28k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 9.28k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 9.28k] | | ------------------ ------------------ 362| 9.28k| IGRAPH_CHECK(igraph_trie_get(t, tmp, id)); ------------------ | | 656| 9.28k| do { \ | | 657| 9.28k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 9.28k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 9.28k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 9.28k] | | | | ------------------ | | ------------------ | | 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| 9.28k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 9.28k] | | ------------------ ------------------ 363| 9.28k| IGRAPH_FREE(tmp); ------------------ | | 36| 9.28k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 364| 9.28k| IGRAPH_FINALLY_CLEAN(1); 365| | 366| 9.28k| return IGRAPH_SUCCESS; 367| 9.28k|} igraph_trie_size: 413| 721|igraph_int_t igraph_trie_size(igraph_trie_t *t) { 414| 721| return t->maxvalue + 1; 415| 721|} 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.33k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) { 42| 2.33k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0); ------------------ | | 62| 2.33k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 2.33k| do { \ | | | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 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.33k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | 63| 2.33k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 2.33k| do { \ | | | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.33k] | | | | ------------------ | | | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 2.33k] | | ------------------ ------------------ 43| 2.33k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0); ------------------ | | 46| 2.33k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 2.33k| do { \ | | | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 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.33k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | 47| 2.33k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 2.33k| do { \ | | | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.33k] | | | | ------------------ | | | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 2.33k] | | ------------------ ------------------ 44| 2.33k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0); ------------------ | | 119| 2.33k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 2.33k| do { \ | | | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 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.33k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | 120| 2.33k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 2.33k| do { \ | | | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.33k] | | | | ------------------ | | | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 2.33k] | | ------------------ ------------------ 45| 2.33k| IGRAPH_FINALLY_CLEAN(3); 46| 2.33k| return IGRAPH_SUCCESS; 47| 2.33k|} trie.c:igraph_i_trie_destroy_node: 91| 2.33k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) { 92| | igraph_i_trie_destroy_node_helper(t, false); 93| 2.33k|} trie.c:igraph_i_trie_destroy_node_helper: 74| 10.9k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) { 75| 10.9k| igraph_strvector_destroy(&t->strs); 76| 10.9k| igraph_int_t children_size = igraph_vector_ptr_size(&t->children); 77| 35.9k| for (igraph_int_t i = 0; i < children_size; i++) { ------------------ | Branch (77:30): [True: 24.9k, False: 10.9k] ------------------ 78| 24.9k| igraph_trie_node_t *child = VECTOR(t->children)[i]; ------------------ | | 60| 24.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 79| 24.9k| if (child != NULL) { ------------------ | Branch (79:13): [True: 8.65k, False: 16.2k] ------------------ 80| 8.65k| igraph_i_trie_destroy_node_helper(child, true); 81| 8.65k| } 82| 24.9k| } 83| 10.9k| igraph_vector_ptr_destroy(&t->children); 84| 10.9k| igraph_vector_int_destroy(&t->values); 85| 10.9k| if (sfree) { ------------------ | Branch (85:9): [True: 8.65k, False: 2.33k] ------------------ 86| | IGRAPH_FREE(t); ------------------ | | 36| 8.65k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 87| 8.65k| } 88| 10.9k|} 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| 6.93M| for (igraph_int_t i = 0; i < strs_size; i++) { ------------------ | Branch (137:30): [True: 6.92M, False: 12.3k] ------------------ 138| 6.92M| size_t diff; 139| 6.92M| const char *str = igraph_strvector_get(&t->strs, i); 140| 6.92M| diff = igraph_i_strdiff(str, key); 141| | 142| 6.92M| if (diff == 0) { ------------------ | Branch (142:13): [True: 5.88M, False: 1.04M] ------------------ 143| | 144| | /* ------------------------------------ */ 145| | /* No match, next */ 146| | 147| 5.88M| } else if (str[diff] == '\0' && key[diff] == '\0') { ------------------ | Branch (147:20): [True: 1.03M, False: 7.23k] | Branch (147:41): [True: 531k, False: 503k] ------------------ 148| | 149| | /* ------------------------------------ */ 150| | /* They are exactly the same */ 151| 531k| if (VECTOR(t->values)[i] != -1) { ------------------ | | 60| 531k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (151:17): [True: 530k, False: 758] ------------------ 152| 530k| *id = VECTOR(t->values)[i]; ------------------ | | 60| 530k|#define VECTOR(v) ((v).stor_begin) ------------------ 153| 530k| return IGRAPH_SUCCESS; 154| 530k| } else { 155| 758| VECTOR(t->values)[i] = newvalue; ------------------ | | 60| 758|#define VECTOR(v) ((v).stor_begin) ------------------ 156| 758| *id = newvalue; 157| 758| return IGRAPH_SUCCESS; 158| 758| } 159| | 160| 531k| } else if (str[diff] == '\0') { ------------------ | Branch (160:20): [True: 503k, False: 7.23k] ------------------ 161| | 162| | /* ------------------------------------ */ 163| | /* str is prefix of key, follow its link if there is one */ 164| 503k| igraph_trie_node_t *node = VECTOR(t->children)[i]; ------------------ | | 60| 503k|#define VECTOR(v) ((v).stor_begin) ------------------ 165| 503k| if (node != NULL) { ------------------ | Branch (165:17): [True: 501k, False: 1.42k] ------------------ 166| 501k| return igraph_i_trie_get_node(node, key + diff, newvalue, id); 167| 501k| } else if (add) { ------------------ | Branch (167:24): [True: 1.42k, False: 0] ------------------ 168| 1.42k| igraph_trie_node_t *new_node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 1.42k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 2.84k| (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.42k, Folded] | | | | ------------------ | | ------------------ ------------------ 169| 1.42k| IGRAPH_CHECK_OOM(new_node, "Cannot add to trie."); ------------------ | | 709| 1.42k| do { \ | | 710| 1.42k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.42k] | | | | ------------------ | | ------------------ | | 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.42k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.42k] | | ------------------ ------------------ 170| 1.42k| IGRAPH_FINALLY(igraph_free, new_node); ------------------ | | 603| 1.42k| do { \ | | 604| 1.42k| /* the following branch makes the compiler check the compatibility of \ | | 605| 1.42k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 1.42k| * incorrect destructor function with the pointer */ \ | | 607| 1.42k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 1.42k] | | ------------------ | | 608| 1.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 1.42k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 1.42k] | | ------------------ ------------------ 171| | 172| 1.42k| IGRAPH_STRVECTOR_INIT_FINALLY(&new_node->strs, 1); ------------------ | | 62| 1.42k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 1.42k| do { \ | | | | 657| 1.42k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.42k] | | | | | | ------------------ | | | | ------------------ | | | | 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.42k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.42k] | | | | ------------------ | | ------------------ | | 63| 1.42k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 1.42k| do { \ | | | | 604| 1.42k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.42k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.42k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.42k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.42k] | | | | ------------------ | | | | 608| 1.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.42k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.42k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 1.42k] | | ------------------ ------------------ 173| 1.42k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&new_node->children, 1); ------------------ | | 46| 1.42k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 1.42k| do { \ | | | | 657| 1.42k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.42k] | | | | | | ------------------ | | | | ------------------ | | | | 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.42k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.42k] | | | | ------------------ | | ------------------ | | 47| 1.42k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 1.42k| do { \ | | | | 604| 1.42k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.42k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.42k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.42k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.42k] | | | | ------------------ | | | | 608| 1.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.42k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.42k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 1.42k] | | ------------------ ------------------ 174| 1.42k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_node->values, 1); ------------------ | | 119| 1.42k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 1.42k| do { \ | | | | 657| 1.42k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.42k] | | | | | | ------------------ | | | | ------------------ | | | | 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.42k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.42k] | | | | ------------------ | | ------------------ | | 120| 1.42k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 1.42k| do { \ | | | | 604| 1.42k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.42k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.42k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.42k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.42k] | | | | ------------------ | | | | 608| 1.42k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.42k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.42k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 1.42k] | | ------------------ ------------------ 175| 1.42k| IGRAPH_CHECK(igraph_strvector_set(&new_node->strs, 0, key + diff)); ------------------ | | 656| 1.42k| do { \ | | 657| 1.42k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.42k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.42k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.42k] | | | | ------------------ | | ------------------ | | 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.42k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.42k] | | ------------------ ------------------ 176| 1.42k| IGRAPH_FINALLY_CLEAN(4); 177| | 178| 1.42k| VECTOR(new_node->children)[0] = 0; ------------------ | | 60| 1.42k|#define VECTOR(v) ((v).stor_begin) ------------------ 179| 1.42k| VECTOR(new_node->values)[0] = newvalue; ------------------ | | 60| 1.42k|#define VECTOR(v) ((v).stor_begin) ------------------ 180| | 181| 1.42k| VECTOR(t->children)[i] = new_node; ------------------ | | 60| 1.42k|#define VECTOR(v) ((v).stor_begin) ------------------ 182| | 183| 1.42k| *id = newvalue; 184| 1.42k| return IGRAPH_SUCCESS; 185| 1.42k| } else { 186| 0| *id = -1; 187| 0| return IGRAPH_SUCCESS; 188| 0| } 189| | 190| 503k| } else if (key[diff] == '\0' && add) { ------------------ | Branch (190:20): [True: 3.25k, False: 3.97k] | Branch (190:41): [True: 3.25k, False: 0] ------------------ 191| | 192| | /* ------------------------------------ */ 193| | /* key is prefix of str, the node has to be cut */ 194| 3.25k| char *str2; 195| | 196| 3.25k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 3.25k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 6.50k| (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.25k, Folded] | | | | ------------------ | | ------------------ ------------------ 197| 3.25k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 709| 3.25k| do { \ | | 710| 3.25k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.25k] | | | | ------------------ | | ------------------ | | 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.25k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.25k] | | ------------------ ------------------ 198| 3.25k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 603| 3.25k| do { \ | | 604| 3.25k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.25k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.25k| * incorrect destructor function with the pointer */ \ | | 607| 3.25k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.25k] | | ------------------ | | 608| 3.25k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.25k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.25k] | | ------------------ ------------------ 199| | 200| 3.25k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1); ------------------ | | 62| 3.25k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 3.25k| do { \ | | | | 657| 3.25k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.25k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.25k] | | | | | | ------------------ | | | | ------------------ | | | | 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.25k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.25k] | | | | ------------------ | | ------------------ | | 63| 3.25k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 3.25k| do { \ | | | | 604| 3.25k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.25k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.25k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.25k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.25k] | | | | ------------------ | | | | 608| 3.25k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.25k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.25k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 3.25k] | | ------------------ ------------------ 201| 3.25k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1); ------------------ | | 46| 3.25k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 3.25k| do { \ | | | | 657| 3.25k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.25k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.25k] | | | | | | ------------------ | | | | ------------------ | | | | 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.25k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.25k] | | | | ------------------ | | ------------------ | | 47| 3.25k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 3.25k| do { \ | | | | 604| 3.25k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.25k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.25k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.25k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.25k] | | | | ------------------ | | | | 608| 3.25k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.25k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.25k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 3.25k] | | ------------------ ------------------ 202| 3.25k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1); ------------------ | | 119| 3.25k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 3.25k| do { \ | | | | 657| 3.25k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.25k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.25k] | | | | | | ------------------ | | | | ------------------ | | | | 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.25k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.25k] | | | | ------------------ | | ------------------ | | 120| 3.25k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 3.25k| do { \ | | | | 604| 3.25k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.25k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.25k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.25k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.25k] | | | | ------------------ | | | | 608| 3.25k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.25k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.25k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 3.25k] | | ------------------ ------------------ 203| 3.25k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 656| 3.25k| do { \ | | 657| 3.25k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.25k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.25k] | | | | ------------------ | | ------------------ | | 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.25k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.25k] | | ------------------ ------------------ 204| | 205| 3.25k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.25k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.25k|#define VECTOR(v) ((v).stor_begin) ------------------ 206| 3.25k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.25k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.25k|#define VECTOR(v) ((v).stor_begin) ------------------ 207| | 208| 3.25k| str2 = strdup(str); 209| 3.25k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 709| 3.25k| do { \ | | 710| 3.25k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.25k] | | | | ------------------ | | ------------------ | | 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.25k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.25k] | | ------------------ ------------------ 210| 3.25k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 603| 3.25k| do { \ | | 604| 3.25k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.25k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.25k| * incorrect destructor function with the pointer */ \ | | 607| 3.25k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.25k] | | ------------------ | | 608| 3.25k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.25k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.25k] | | ------------------ ------------------ 211| 3.25k| str2[diff] = '\0'; 212| | 213| 3.25k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 656| 3.25k| do { \ | | 657| 3.25k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.25k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.25k] | | | | ------------------ | | ------------------ | | 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.25k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.25k] | | ------------------ ------------------ 214| | 215| 3.25k| IGRAPH_FREE(str2); ------------------ | | 36| 3.25k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 216| 3.25k| IGRAPH_FINALLY_CLEAN(5); 217| | 218| 3.25k| VECTOR(t->values)[i] = newvalue; ------------------ | | 60| 3.25k|#define VECTOR(v) ((v).stor_begin) ------------------ 219| 3.25k| VECTOR(t->children)[i] = node; ------------------ | | 60| 3.25k|#define VECTOR(v) ((v).stor_begin) ------------------ 220| | 221| 3.25k| *id = newvalue; 222| 3.25k| return IGRAPH_SUCCESS; 223| | 224| 3.97k| } else if (add) { ------------------ | Branch (224:20): [True: 3.97k, False: 0] ------------------ 225| | 226| | /* ------------------------------------ */ 227| | /* the first diff characters match */ 228| 3.97k| char *str2; 229| | 230| 3.97k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 3.97k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 7.95k| (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.97k, Folded] | | | | ------------------ | | ------------------ ------------------ 231| 3.97k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 709| 3.97k| do { \ | | 710| 3.97k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | ------------------ | | ------------------ | | 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.97k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.97k] | | ------------------ ------------------ 232| 3.97k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 603| 3.97k| do { \ | | 604| 3.97k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.97k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.97k| * incorrect destructor function with the pointer */ \ | | 607| 3.97k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.97k] | | ------------------ | | 608| 3.97k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.97k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.97k] | | ------------------ ------------------ 233| | 234| 3.97k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2); ------------------ | | 62| 3.97k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 3.97k| do { \ | | | | 657| 3.97k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.97k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | | | ------------------ | | | | ------------------ | | | | 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.97k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.97k] | | | | ------------------ | | ------------------ | | 63| 3.97k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 3.97k| do { \ | | | | 604| 3.97k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.97k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.97k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.97k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.97k] | | | | ------------------ | | | | 608| 3.97k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.97k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.97k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 3.97k] | | ------------------ ------------------ 235| 3.97k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2); ------------------ | | 46| 3.97k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 3.97k| do { \ | | | | 657| 3.97k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.97k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | | | ------------------ | | | | ------------------ | | | | 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.97k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.97k] | | | | ------------------ | | ------------------ | | 47| 3.97k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 3.97k| do { \ | | | | 604| 3.97k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.97k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.97k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.97k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.97k] | | | | ------------------ | | | | 608| 3.97k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.97k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.97k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 3.97k] | | ------------------ ------------------ 236| 3.97k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2); ------------------ | | 119| 3.97k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 3.97k| do { \ | | | | 657| 3.97k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.97k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | | | ------------------ | | | | ------------------ | | | | 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.97k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.97k] | | | | ------------------ | | ------------------ | | 120| 3.97k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 3.97k| do { \ | | | | 604| 3.97k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.97k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.97k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.97k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.97k] | | | | ------------------ | | | | 608| 3.97k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.97k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.97k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 3.97k] | | ------------------ ------------------ 237| 3.97k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 656| 3.97k| do { \ | | 657| 3.97k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.97k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | ------------------ | | ------------------ | | 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.97k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.97k] | | ------------------ ------------------ 238| 3.97k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff)); ------------------ | | 656| 3.97k| do { \ | | 657| 3.97k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.97k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | ------------------ | | ------------------ | | 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.97k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.97k] | | ------------------ ------------------ 239| 3.97k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ 240| 3.97k| VECTOR(node->children)[1] = 0; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ 241| 3.97k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ 242| 3.97k| VECTOR(node->values)[1] = newvalue; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ 243| | 244| 3.97k| str2 = strdup(str); 245| 3.97k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 709| 3.97k| do { \ | | 710| 3.97k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | ------------------ | | ------------------ | | 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.97k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.97k] | | ------------------ ------------------ 246| | 247| 3.97k| str2[diff] = '\0'; 248| 3.97k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 603| 3.97k| do { \ | | 604| 3.97k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.97k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.97k| * incorrect destructor function with the pointer */ \ | | 607| 3.97k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.97k] | | ------------------ | | 608| 3.97k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.97k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.97k] | | ------------------ ------------------ 249| | 250| 3.97k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 656| 3.97k| do { \ | | 657| 3.97k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.97k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.97k] | | | | ------------------ | | ------------------ | | 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.97k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.97k] | | ------------------ ------------------ 251| | 252| 3.97k| IGRAPH_FREE(str2); ------------------ | | 36| 3.97k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 253| 3.97k| IGRAPH_FINALLY_CLEAN(5); 254| | 255| 3.97k| VECTOR(t->values)[i] = -1; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ 256| 3.97k| VECTOR(t->children)[i] = node; ------------------ | | 60| 3.97k|#define VECTOR(v) ((v).stor_begin) ------------------ 257| | 258| 3.97k| *id = newvalue; 259| 3.97k| return IGRAPH_SUCCESS; 260| 3.97k| } 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| 6.92M| } 268| | 269| | /* ------------------------------------ */ 270| | /* Nothing matches */ 271| | 272| 12.3k| if (add) { ------------------ | Branch (272:9): [True: 12.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| 12.3k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key)); ------------------ | | 656| 12.3k| do { \ | | 657| 12.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 12.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 12.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 12.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| 12.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 12.3k] | | ------------------ ------------------ 278| 12.3k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL)); ------------------ | | 656| 12.3k| do { \ | | 657| 12.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 12.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 12.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 12.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| 12.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 12.3k] | | ------------------ ------------------ 279| 12.3k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue)); ------------------ | | 656| 12.3k| do { \ | | 657| 12.3k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 12.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 12.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 12.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| 12.3k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 12.3k] | | ------------------ ------------------ 280| 12.3k| *id = newvalue; 281| 12.3k| } else { 282| 0| *id = -1; 283| 0| } 284| | 285| 12.3k| return IGRAPH_SUCCESS; 286| 12.3k|} trie.c:igraph_i_strdiff: 111| 6.92M|static size_t igraph_i_strdiff(const char *str, const char *key) { 112| 6.92M| size_t diff = 0; 113| 8.36M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) { ------------------ | Branch (113:12): [True: 7.82M, False: 534k] | Branch (113:33): [True: 7.32M, False: 503k] | Branch (113:54): [True: 1.43M, False: 5.88M] ------------------ 114| 1.43M| diff++; 115| 1.43M| } 116| 6.92M| return diff; 117| 6.92M|} igraph_attribute_record_list_init: 109| 2.88k|igraph_error_t FUNCTION(init)(TYPE *v, igraph_int_t size) { 110| 2.88k| igraph_int_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (110:31): [True: 426, False: 2.46k] ------------------ 111| 2.88k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 2.88k| do { \ | | 925| 2.88k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.88k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.88k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.88k] | | ------------------ ------------------ 112| 2.88k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE); ------------------ | | 33| 2.88k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 5.77k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 2.88k, False: 0] | | | | | Branch (31:24): [True: 2.88k, False: 0] | | | | | Branch (31:66): [True: 2.88k, False: 0] | | | | ------------------ | | ------------------ ------------------ 113| 2.88k| if (v->stor_begin == 0) { ------------------ | Branch (113:9): [True: 0, False: 2.88k] ------------------ 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.88k| v->stor_end = v->stor_begin + alloc_size; 117| 2.88k| v->end = v->stor_begin + size; 118| | 119| 2.88k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end)); ------------------ | | 656| 2.88k| do { \ | | 657| 2.88k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.88k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.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| 2.88k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.88k] | | ------------------ ------------------ 120| | 121| 2.88k| return IGRAPH_SUCCESS; 122| 2.88k|} igraph_attribute_record_list_destroy: 176| 2.88k|void FUNCTION(destroy)(TYPE *v) { 177| 2.88k| IGRAPH_ASSERT(v != 0); ------------------ | | 924| 2.88k| do { \ | | 925| 2.88k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.88k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.88k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.88k] | | ------------------ ------------------ 178| | 179| 2.88k| if (v->stor_begin != 0) { ------------------ | Branch (179:9): [True: 2.88k, False: 0] ------------------ 180| 2.88k| FUNCTION(clear)(v); ------------------ | | 161| 2.88k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c) | | ------------------ | | | | 19| 2.88k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 181| 2.88k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 2.88k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 182| | v->stor_begin = NULL; 183| 2.88k| } 184| 2.88k|} igraph_attribute_record_list_size: 287| 3.23k|igraph_int_t FUNCTION(size)(const TYPE *v) { 288| 3.23k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 3.23k| do { \ | | 925| 3.23k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.23k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.23k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.23k] | | ------------------ ------------------ 289| 3.23k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 3.23k| do { \ | | 925| 3.23k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.23k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.23k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.23k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.23k] | | ------------------ ------------------ 290| 3.23k| return v->end - v->stor_begin; 291| 3.23k|} igraph_attribute_record_list_clear: 357| 2.88k|void FUNCTION(clear)(TYPE *v) { 358| 2.88k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.88k| do { \ | | 925| 2.88k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.88k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.88k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.88k] | | ------------------ ------------------ 359| 2.88k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 2.88k| do { \ | | 925| 2.88k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.88k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.88k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.88k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.88k] | | ------------------ ------------------ 360| 2.88k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end); ------------------ | | 162| 2.88k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 2.88k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 361| 2.88k| v->end = v->stor_begin; 362| 2.88k|} igraph_attribute_record_list_get_ptr: 377| 1.84k|ITEM_TYPE *FUNCTION(get_ptr)(const TYPE *v, igraph_int_t pos) { 378| 1.84k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 1.84k| do { \ | | 925| 1.84k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.84k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.84k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.84k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.84k] | | ------------------ ------------------ 379| 1.84k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 1.84k| do { \ | | 925| 1.84k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.84k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.84k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.84k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.84k] | | ------------------ ------------------ 380| 1.84k| return v->stor_begin + pos; 381| 1.84k|} igraph_attribute_record_list_push_back_new: 640| 319|igraph_error_t FUNCTION(push_back_new)(TYPE *v, ITEM_TYPE** e) { 641| 319| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v)); ------------------ | | 656| 319| do { \ | | 657| 319| igraph_error_t igraph_i_ret = (expr); \ | | 658| 319| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 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| 319| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 319] | | ------------------ ------------------ 642| 319| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end)); ------------------ | | 656| 319| do { \ | | 657| 319| igraph_error_t igraph_i_ret = (expr); \ | | 658| 319| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 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| 319| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 319] | | ------------------ ------------------ 643| 319| if (e) { ------------------ | Branch (643:9): [True: 319, False: 0] ------------------ 644| 319| *e = v->end; 645| 319| } 646| 319| v->end += 1; 647| 319| return IGRAPH_SUCCESS; 648| 319|} attributes.c:igraph_i_attribute_record_list_init_slice: 1068| 2.88k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1069| 2.88k| ITEM_TYPE *current; ------------------ | | 61| 2.88k| #define ITEM_TYPE BASE | | ------------------ | | | | 115| 2.88k| #define BASE igraph_attribute_record_t | | ------------------ ------------------ 1070| 2.88k| igraph_error_t retval; 1071| | 1072| 3.31k| for (current = start; current < end; current++) { ------------------ | Branch (1072:27): [True: 426, False: 2.88k] ------------------ 1073| 426| retval = INTERNAL_FUNCTION(init_item)(list, current); ------------------ | | 162| 426| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 426|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1074| 426| if (retval) { ------------------ | Branch (1074:13): [True: 0, False: 426] ------------------ 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| 426| } 1079| | 1080| 2.88k| return IGRAPH_SUCCESS; 1081| 2.88k|} attributes.c:igraph_i_attribute_record_list_destroy_slice: 1083| 2.88k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1084| 2.88k| IGRAPH_UNUSED(list); ------------------ | | 30| 2.88k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 1085| 3.63k| for (; start < end; start++) { ------------------ | Branch (1085:12): [True: 745, False: 2.88k] ------------------ 1086| 745| INTERNAL_FUNCTION(destroy_item)(start); ------------------ | | 162| 745| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 745|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1087| 745| } 1088| 2.88k|} attributes.c:igraph_i_attribute_record_list_expand_if_full: 1094| 319|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE *v) { 1095| 319| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 319| do { \ | | 925| 319| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 319| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 319] | | ------------------ ------------------ 1096| 319| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 319| do { \ | | 925| 319| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 319| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 319] | | ------------------ ------------------ 1097| | 1098| 319| if (v->stor_end == v->end) { ------------------ | Branch (1098:9): [True: 0, False: 319] ------------------ 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| 319| return IGRAPH_SUCCESS; 1111| 319|} igraph_vector_int_pair_order: 119| 992| igraph_vector_int_t* res, igraph_int_t nodes) { 120| 992| igraph_int_t edges = igraph_vector_int_size(v); 121| 992| igraph_vector_int_t ptr; 122| 992| igraph_vector_int_t rad; 123| 992| igraph_int_t i, j; 124| | 125| 992| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 992| do { \ | | 925| 992| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 992| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 992] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 992| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 992] | | ------------------ ------------------ 126| 992| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 992| do { \ | | 925| 992| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 992| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 992] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 992| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 992] | | ------------------ ------------------ 127| | 128| 992| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1); ------------------ | | 119| 992| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 992| do { \ | | | | 657| 992| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 992| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 992| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 992] | | | | | | ------------------ | | | | ------------------ | | | | 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| 992| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 992] | | | | ------------------ | | ------------------ | | 120| 992| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 992| do { \ | | | | 604| 992| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 992| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 992| * incorrect destructor function with the pointer */ \ | | | | 607| 992| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 992] | | | | ------------------ | | | | 608| 992| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 992| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 992] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 992] | | ------------------ ------------------ 129| 992| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges); ------------------ | | 119| 992| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 992| do { \ | | | | 657| 992| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 992| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 992| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 992] | | | | | | ------------------ | | | | ------------------ | | | | 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| 992| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 992] | | | | ------------------ | | ------------------ | | 120| 992| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 992| do { \ | | | | 604| 992| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 992| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 992| * incorrect destructor function with the pointer */ \ | | | | 607| 992| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 992] | | | | ------------------ | | | | 608| 992| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 992| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 992] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 992] | | ------------------ ------------------ 130| 992| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 656| 992| do { \ | | 657| 992| igraph_error_t igraph_i_ret = (expr); \ | | 658| 992| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 992| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 992] | | | | ------------------ | | ------------------ | | 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| 992| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 992] | | ------------------ ------------------ 131| | 132| 6.32M| for (i = 0; i < edges; i++) { ------------------ | Branch (132:17): [True: 6.32M, False: 992] ------------------ 133| 6.32M| igraph_int_t radix = VECTOR(*v2)[i]; ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ 134| 6.32M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (134:13): [True: 6.28M, False: 35.5k] ------------------ 135| 6.28M| VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 136| 6.28M| } 137| 6.32M| VECTOR(ptr)[radix] = i + 1; ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ 138| 6.32M| } 139| | 140| 992| j = 0; 141| 80.5M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (141:17): [True: 80.5M, False: 992] ------------------ 142| 80.5M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 60| 80.5M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (142:13): [True: 35.5k, False: 80.5M] ------------------ 143| 35.5k| igraph_int_t next = VECTOR(ptr)[i] - 1; ------------------ | | 60| 35.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 144| 35.5k| VECTOR(*res)[j++] = next; ------------------ | | 60| 35.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 145| 6.32M| while (VECTOR(rad)[next] != 0) { ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (145:20): [True: 6.28M, False: 35.5k] ------------------ 146| 6.28M| next = VECTOR(rad)[next] - 1; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 147| 6.28M| VECTOR(*res)[j++] = next; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 148| 6.28M| } 149| 35.5k| } 150| 80.5M| } 151| | 152| 992| igraph_vector_int_null(&ptr); 153| 992| igraph_vector_int_null(&rad); 154| | 155| 6.32M| for (i = 0; i < edges; i++) { ------------------ | Branch (155:17): [True: 6.32M, False: 992] ------------------ 156| 6.32M| igraph_int_t edge = VECTOR(*res)[edges - i - 1]; ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ 157| 6.32M| igraph_int_t radix = VECTOR(*v)[edge]; ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ 158| 6.32M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (158:13): [True: 6.28M, False: 35.5k] ------------------ 159| 6.28M| VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 160| 6.28M| } 161| 6.32M| VECTOR(ptr)[radix] = edge + 1; ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ 162| 6.32M| } 163| | 164| 992| j = 0; 165| 80.5M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (165:17): [True: 80.5M, False: 992] ------------------ 166| 80.5M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 60| 80.5M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (166:13): [True: 35.5k, False: 80.5M] ------------------ 167| 35.5k| igraph_int_t next = VECTOR(ptr)[i] - 1; ------------------ | | 60| 35.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 168| 35.5k| VECTOR(*res)[j++] = next; ------------------ | | 60| 35.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 169| 6.32M| while (VECTOR(rad)[next] != 0) { ------------------ | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (169:20): [True: 6.28M, False: 35.5k] ------------------ 170| 6.28M| next = VECTOR(rad)[next] - 1; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 171| 6.28M| VECTOR(*res)[j++] = next; ------------------ | | 60| 6.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 172| 6.28M| } 173| 35.5k| } 174| 80.5M| } 175| | 176| 992| igraph_vector_int_destroy(&ptr); 177| 992| igraph_vector_int_destroy(&rad); 178| 992| IGRAPH_FINALLY_CLEAN(2); 179| | 180| 992| return IGRAPH_SUCCESS; 181| 992|} 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| 38.0k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) { 437| 38.0k| return v->stor_end - v->stor_begin; 438| 38.0k|} igraph_vector_reserve: 468| 37.9k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) { 469| 37.9k| igraph_int_t current_capacity; 470| 37.9k| BASE *tmp; ------------------ | | 29| 37.9k| #define BASE igraph_real_t ------------------ 471| | 472| 37.9k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 37.9k| do { \ | | 925| 37.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 37.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.9k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 37.9k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 37.9k] | | ------------------ ------------------ 473| 37.9k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 37.9k| do { \ | | 925| 37.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 37.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.9k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 37.9k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 37.9k] | | ------------------ ------------------ 474| 37.9k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 37.9k| do { \ | | 925| 37.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 37.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.9k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 37.9k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 37.9k] | | ------------------ ------------------ 475| | 476| 37.9k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 170| 37.9k| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 37.9k|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 37.9k|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 477| | 478| 37.9k| if (capacity <= current_capacity) { ------------------ | Branch (478:9): [True: 36.6k, False: 1.24k] ------------------ 479| 36.6k| return IGRAPH_SUCCESS; 480| 36.6k| } 481| | 482| 1.24k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 35| 1.24k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 2.49k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 1.24k, False: 0] | | | | | Branch (31:24): [True: 1.24k, False: 0] | | | | | Branch (31:66): [True: 1.24k, False: 0] | | | | ------------------ | | ------------------ ------------------ 483| 1.24k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 709| 1.24k| do { \ | | 710| 1.24k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.24k] | | | | ------------------ | | ------------------ | | 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.24k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.24k] | | ------------------ ------------------ 484| | 485| 1.24k| v->end = tmp + (v->end - v->stor_begin); 486| 1.24k| v->stor_begin = tmp; 487| 1.24k| v->stor_end = v->stor_begin + capacity; 488| | 489| 1.24k| return IGRAPH_SUCCESS; 490| 1.24k|} igraph_vector_size: 522| 41.6k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) { 523| 41.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 41.6k| do { \ | | 925| 41.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 41.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 41.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 41.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 41.6k] | | ------------------ ------------------ 524| 41.6k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 41.6k| do { \ | | 925| 41.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 41.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 41.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 41.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 41.6k] | | ------------------ ------------------ 525| 41.6k| return v->end - v->stor_begin; 526| 41.6k|} igraph_vector_push_back: 573| 38.6k|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) { 574| 38.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 38.6k| do { \ | | 925| 38.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 38.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 38.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 38.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 38.6k] | | ------------------ ------------------ 575| 38.6k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 38.6k| do { \ | | 925| 38.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 38.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 38.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 38.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 38.6k] | | ------------------ ------------------ 576| | 577| 38.6k| if (v->stor_end == v->end) { ------------------ | Branch (577:9): [True: 663, False: 37.9k] ------------------ 578| | /* full, allocate more storage */ 579| 663| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 170| 663| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 663|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 663|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 580| 663| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 663|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 663|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (580:33): [True: 663, False: 0] ------------------ 581| 663| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 663|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (581:13): [True: 0, False: 663] ------------------ 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| 663| if (new_size == 0) { ------------------ | Branch (584:13): [True: 0, False: 663] ------------------ 585| 0| new_size = 1; 586| 0| } 587| 663| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 663| do { \ | | 657| 663| igraph_error_t igraph_i_ret = (expr); \ | | 658| 663| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 663| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 663] | | | | ------------------ | | ------------------ | | 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| 663| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 663] | | ------------------ ------------------ 588| 663| } 589| | 590| 38.6k| *(v->end) = e; 591| 38.6k| v->end += 1; 592| | 593| 38.6k| return IGRAPH_SUCCESS; 594| 38.6k|} igraph_vector_resize: 1264| 37.1k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) { 1265| 37.1k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 37.1k| do { \ | | 925| 37.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 37.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.1k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 37.1k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 37.1k] | | ------------------ ------------------ 1266| 37.1k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 37.1k| do { \ | | 925| 37.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 37.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.1k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 37.1k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 37.1k] | | ------------------ ------------------ 1267| 37.1k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 37.1k| do { \ | | 657| 37.1k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 37.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 37.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37.1k] | | | | ------------------ | | ------------------ | | 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| 37.1k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 37.1k] | | ------------------ ------------------ 1268| 37.1k| v->end = v->stor_begin + new_size; 1269| 37.1k| return IGRAPH_SUCCESS; 1270| 37.1k|} igraph_vector_append: 2427| 144| const TYPE(igraph_vector) *from) { 2428| 144| IGRAPH_ASSERT(to != NULL); ------------------ | | 924| 144| do { \ | | 925| 144| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 144| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 144] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 144| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 144] | | ------------------ ------------------ 2429| 144| IGRAPH_ASSERT(to->stor_begin != NULL); ------------------ | | 924| 144| do { \ | | 925| 144| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 144| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 144] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 144| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 144] | | ------------------ ------------------ 2430| | 2431| 144| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to); ------------------ | | 170| 144| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 144|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 144|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2432| 144| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from); ------------------ | | 170| 144| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 144|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 144|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2433| 144| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to); ------------------ | | 170| 144| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 144|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 144|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2434| 144| igraph_int_t new_to_size; 2435| | 2436| 144| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 144| do { \ | | 48| 144| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 144| igraph_int_t _safe_sum; \ | | 50| 144| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 144] | | ------------------ | | 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| 144| *(res) = _safe_sum; \ | | 54| 144| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 144] | | ------------------ ------------------ 2437| | 2438| 144| if (to_capacity < new_to_size) { ------------------ | Branch (2438:9): [True: 138, False: 6] ------------------ 2439| 138| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 138|# 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| 138|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (2439:40): [True: 138, False: 0] ------------------ 2440| 138| if (new_to_capacity < new_to_size) { ------------------ | Branch (2440:13): [True: 135, False: 3] ------------------ 2441| 135| new_to_capacity = new_to_size; 2442| 135| } 2443| 138| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity)); ------------------ | | 656| 138| do { \ | | 657| 138| igraph_error_t igraph_i_ret = (expr); \ | | 658| 138| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 138] | | | | ------------------ | | ------------------ | | 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| 138| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 138] | | ------------------ ------------------ 2444| 138| } 2445| | 2446| 144| memcpy(to->stor_begin + to_size, from->stor_begin, 2447| 144| sizeof(BASE) * from_size); 2448| 144| to->end = to->stor_begin + new_to_size; 2449| | 2450| 144| return IGRAPH_SUCCESS; 2451| 144|} igraph_vector_swap: 2541| 251|void FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) { 2542| | 2543| 251| TYPE(igraph_vector) tmp; ------------------ | | 171| 251| #define TYPE(a) CONCAT2(a,t) | | ------------------ | | | | 20| 251|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 251|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2544| | 2545| 251| tmp = *v1; 2546| 251| *v1 = *v2; 2547| 251| *v2 = tmp; 2548| 251|} igraph_vector_int_init: 134| 21.2k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) { 135| 21.2k| igraph_int_t alloc_size; 136| 21.2k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 21.2k| do { \ | | 925| 21.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 21.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 21.2k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 21.2k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 21.2k] | | ------------------ ------------------ 137| 21.2k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (137:18): [True: 11.9k, False: 9.25k] ------------------ 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| 21.2k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 33| 21.2k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 42.4k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 21.2k, False: 0] | | | | | Branch (31:24): [True: 21.2k, False: 0] | | | | | Branch (31:66): [True: 21.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ 144| 21.2k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector."); ------------------ | | 709| 21.2k| do { \ | | 710| 21.2k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 21.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 21.2k] | | | | ------------------ | | ------------------ | | 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| 21.2k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 21.2k] | | ------------------ ------------------ 145| 21.2k| v->stor_end = v->stor_begin + alloc_size; 146| 21.2k| v->end = v->stor_begin + size; 147| | 148| 21.2k| return IGRAPH_SUCCESS; 149| 21.2k|} igraph_vector_int_destroy: 408| 21.2k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) { 409| 21.2k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 21.2k| do { \ | | 925| 21.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 21.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 21.2k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 21.2k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 21.2k] | | ------------------ ------------------ 410| | /* vector_init() will leave stor_begin set to NULL when it fails. 411| | * We handle these cases gracefully. */ 412| 21.2k| if (v->stor_begin != NULL) { ------------------ | Branch (412:9): [True: 21.2k, False: 0] ------------------ 413| 21.2k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 21.2k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 414| | v->stor_begin = NULL; 415| 21.2k| } 416| 21.2k|} igraph_vector_int_capacity: 436| 17.8k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) { 437| 17.8k| return v->stor_end - v->stor_begin; 438| 17.8k|} igraph_vector_int_reserve: 468| 17.8k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) { 469| 17.8k| igraph_int_t current_capacity; 470| 17.8k| BASE *tmp; ------------------ | | 66| 17.8k| #define BASE igraph_int_t ------------------ 471| | 472| 17.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 17.8k| do { \ | | 925| 17.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.8k] | | ------------------ ------------------ 473| 17.8k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 17.8k| do { \ | | 925| 17.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.8k] | | ------------------ ------------------ 474| 17.8k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 17.8k| do { \ | | 925| 17.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.8k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.8k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.8k] | | ------------------ ------------------ 475| | 476| 17.8k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 178| 17.8k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 17.8k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 17.8k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 477| | 478| 17.8k| if (capacity <= current_capacity) { ------------------ | Branch (478:9): [True: 7.18k, False: 10.6k] ------------------ 479| 7.18k| return IGRAPH_SUCCESS; 480| 7.18k| } 481| | 482| 10.6k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 35| 10.6k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 21.3k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 10.6k, False: 0] | | | | | Branch (31:24): [True: 10.6k, False: 0] | | | | | Branch (31:66): [True: 10.6k, False: 0] | | | | ------------------ | | ------------------ ------------------ 483| 10.6k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 709| 10.6k| do { \ | | 710| 10.6k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 10.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.6k] | | | | ------------------ | | ------------------ | | 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.6k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 10.6k] | | ------------------ ------------------ 484| | 485| 10.6k| v->end = tmp + (v->end - v->stor_begin); 486| 10.6k| v->stor_begin = tmp; 487| 10.6k| v->stor_end = v->stor_begin + capacity; 488| | 489| 10.6k| return IGRAPH_SUCCESS; 490| 10.6k|} igraph_vector_int_empty: 503| 587|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector) *v) { 504| 587| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 587| do { \ | | 925| 587| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 587| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 587] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 587| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 587] | | ------------------ ------------------ 505| 587| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 587| do { \ | | 925| 587| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 587| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 587] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 587| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 587] | | ------------------ ------------------ 506| 587| return v->stor_begin == v->end; 507| 587|} igraph_vector_int_size: 522| 58.4k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) { 523| 58.4k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 58.4k| do { \ | | 925| 58.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 58.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 58.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 58.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 58.4k] | | ------------------ ------------------ 524| 58.4k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 58.4k| do { \ | | 925| 58.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 58.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 58.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 58.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 58.4k] | | ------------------ ------------------ 525| 58.4k| return v->end - v->stor_begin; 526| 58.4k|} igraph_vector_int_push_back: 573| 14.1M|igraph_error_t FUNCTION(igraph_vector, push_back)(TYPE(igraph_vector) *v, BASE e) { 574| 14.1M| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 14.1M| do { \ | | 925| 14.1M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 14.1M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 14.1M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 14.1M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 14.1M] | | ------------------ ------------------ 575| 14.1M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 14.1M| do { \ | | 925| 14.1M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 14.1M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 14.1M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 14.1M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 14.1M] | | ------------------ ------------------ 576| | 577| 14.1M| if (v->stor_end == v->end) { ------------------ | Branch (577:9): [True: 8.05k, False: 14.1M] ------------------ 578| | /* full, allocate more storage */ 579| 8.05k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 178| 8.05k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 8.05k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 8.05k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 580| 8.05k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 8.05k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 8.05k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (580:33): [True: 8.05k, False: 0] ------------------ 581| 8.05k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 8.05k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (581:13): [True: 0, False: 8.05k] ------------------ 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| 8.05k| if (new_size == 0) { ------------------ | Branch (584:13): [True: 0, False: 8.05k] ------------------ 585| 0| new_size = 1; 586| 0| } 587| 8.05k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 8.05k| do { \ | | 657| 8.05k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 8.05k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 8.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.05k] | | | | ------------------ | | ------------------ | | 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.05k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 8.05k] | | ------------------ ------------------ 588| 8.05k| } 589| | 590| 14.1M| *(v->end) = e; 591| 14.1M| v->end += 1; 592| | 593| 14.1M| return IGRAPH_SUCCESS; 594| 14.1M|} igraph_vector_int_null: 725| 2.29k|void FUNCTION(igraph_vector, null)(TYPE(igraph_vector) *v) { 726| 2.29k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.29k| do { \ | | 925| 2.29k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.29k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.29k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.29k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.29k] | | ------------------ ------------------ 727| 2.29k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 2.29k| do { \ | | 925| 2.29k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.29k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.29k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.29k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.29k] | | ------------------ ------------------ 728| 2.29k| if (FUNCTION(igraph_vector, size)(v) > 0) { ------------------ | | 178| 2.29k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 2.29k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 2.29k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ | Branch (728:9): [True: 1.98k, False: 306] ------------------ 729| 1.98k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v)); ------------------ | | 178| 1.98k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 1.98k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 1.98k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 730| 1.98k| } 731| 2.29k|} igraph_vector_int_resize: 1264| 5.54k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) { 1265| 5.54k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 5.54k| do { \ | | 925| 5.54k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 5.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.54k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 5.54k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 5.54k] | | ------------------ ------------------ 1266| 5.54k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 5.54k| do { \ | | 925| 5.54k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 5.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.54k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 5.54k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 5.54k] | | ------------------ ------------------ 1267| 5.54k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 5.54k| do { \ | | 657| 5.54k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 5.54k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 5.54k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.54k] | | | | ------------------ | | ------------------ | | 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.54k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 5.54k] | | ------------------ ------------------ 1268| 5.54k| v->end = v->stor_begin + new_size; 1269| 5.54k| return IGRAPH_SUCCESS; 1270| 5.54k|} igraph_vector_int_max: 1327| 587|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector) *v) { 1328| 587| BASE max; ------------------ | | 66| 587| #define BASE igraph_int_t ------------------ 1329| 587| BASE *ptr; ------------------ | | 66| 587| #define BASE igraph_int_t ------------------ 1330| 587| IGRAPH_ASSERT(!FUNCTION(igraph_vector, empty)(v)); ------------------ | | 924| 587| do { \ | | 925| 587| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 587| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 587] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 587| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 587] | | ------------------ ------------------ 1331| 587| max = *(v->stor_begin); 1332| |#if defined(BASE_IGRAPH_REAL) 1333| | if (isnan(max)) { return max; }; /* Result is NaN */ 1334| |#endif 1335| 587| ptr = v->stor_begin + 1; 1336| 6.47M| while (ptr < v->end) { ------------------ | Branch (1336:12): [True: 6.47M, False: 587] ------------------ 1337| 6.47M| if ((*ptr) > max) { ------------------ | Branch (1337:13): [True: 37.2k, False: 6.43M] ------------------ 1338| 37.2k| max = *ptr; 1339| 37.2k| } 1340| |#if defined(BASE_IGRAPH_REAL) 1341| | else if (isnan(*ptr)) 1342| | return *ptr; /* Result is NaN */ 1343| |#endif 1344| 6.47M| ptr++; 1345| 6.47M| } 1346| 587| return max; 1347| 587|} igraph_vector_int_isininterval: 1832| 682| BASE high) { 1833| 682| BASE *ptr; ------------------ | | 66| 682| #define BASE igraph_int_t ------------------ 1834| 682| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 682| do { \ | | 925| 682| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 682| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 682] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 682| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 682] | | ------------------ ------------------ 1835| 682| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 682| do { \ | | 925| 682| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 682| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 682] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 682| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 682] | | ------------------ ------------------ 1836| 6.35M| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (1836:31): [True: 6.35M, False: 496] ------------------ 1837| | /* Note that the following is not equivalent to *ptr < low || *ptr > high 1838| | * when *ptr is NaN! */ 1839| 6.35M| if (!(*ptr >= low && *ptr <= high)) { ------------------ | Branch (1839:15): [True: 6.35M, False: 0] | Branch (1839:30): [True: 6.35M, False: 186] ------------------ 1840| 186| return 0; 1841| 186| } 1842| 6.35M| } 1843| 496| return 1; 1844| 682|} igraph_vector_ptr_init: 86| 10.9k|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_int_t size) { 87| 10.9k| igraph_int_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (87:31): [True: 8.65k, False: 2.33k] ------------------ 88| 10.9k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 10.9k| do { \ | | 925| 10.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 10.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.9k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 10.9k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 10.9k] | | ------------------ ------------------ 89| 10.9k| if (size < 0) { ------------------ | Branch (89:9): [True: 0, False: 10.9k] ------------------ 90| 0| size = 0; 91| 0| } 92| 10.9k| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*); ------------------ | | 33| 10.9k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 21.9k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 10.9k, False: 0] | | | | | Branch (31:24): [True: 10.9k, False: 0] | | | | | Branch (31:66): [True: 10.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 93| 10.9k| if (v->stor_begin == 0) { ------------------ | Branch (93:9): [True: 0, False: 10.9k] ------------------ 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.9k| v->stor_end = v->stor_begin + alloc_size; 97| 10.9k| v->end = v->stor_begin + size; 98| 10.9k| v->item_destructor = 0; 99| | 100| 10.9k| return IGRAPH_SUCCESS; 101| 10.9k|} igraph_vector_ptr_destroy: 132| 10.9k|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) { 133| 10.9k| IGRAPH_ASSERT(v != 0); ------------------ | | 924| 10.9k| do { \ | | 925| 10.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 10.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.9k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 10.9k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 10.9k] | | ------------------ ------------------ 134| 10.9k| if (v->stor_begin != 0) { ------------------ | Branch (134:9): [True: 10.9k, False: 0] ------------------ 135| 10.9k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 10.9k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 136| | v->stor_begin = NULL; 137| 10.9k| } 138| 10.9k|} igraph_vector_ptr_reserve: 215| 3.90k|igraph_error_t igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, igraph_int_t capacity) { 216| 3.90k| igraph_int_t actual_size = igraph_vector_ptr_size(v); 217| 3.90k| void **tmp; 218| 3.90k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 3.90k| do { \ | | 925| 3.90k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.90k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.90k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.90k] | | ------------------ ------------------ 219| 3.90k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 3.90k| do { \ | | 925| 3.90k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.90k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.90k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.90k] | | ------------------ ------------------ 220| 3.90k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 3.90k| do { \ | | 925| 3.90k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.90k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.90k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.90k] | | ------------------ ------------------ 221| | 222| 3.90k| if (capacity <= igraph_vector_ptr_size(v)) { ------------------ | Branch (222:9): [True: 0, False: 3.90k] ------------------ 223| 0| return IGRAPH_SUCCESS; 224| 0| } 225| | 226| 3.90k| tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) capacity, void*); ------------------ | | 35| 3.90k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 7.81k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 3.90k, False: 0] | | | | | Branch (31:24): [True: 3.90k, False: 0] | | | | | Branch (31:66): [True: 3.90k, False: 0] | | | | ------------------ | | ------------------ ------------------ 227| 3.90k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for pointer vector."); ------------------ | | 709| 3.90k| do { \ | | 710| 3.90k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.90k] | | | | ------------------ | | ------------------ | | 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.90k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.90k] | | ------------------ ------------------ 228| | 229| 3.90k| v->stor_begin = tmp; 230| 3.90k| v->stor_end = v->stor_begin + capacity; 231| 3.90k| v->end = v->stor_begin + actual_size; 232| | 233| 3.90k| return IGRAPH_SUCCESS; 234| 3.90k|} igraph_vector_ptr_size: 291| 18.8k|igraph_int_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) { 292| 18.8k| IGRAPH_ASSERT(v != 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] | | ------------------ ------------------ 293| 18.8k| IGRAPH_ASSERT(v->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] | | ------------------ ------------------ 294| 18.8k| return v->end - v->stor_begin; 295| 18.8k|} igraph_vector_ptr_push_back: 360| 12.3k|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) { 361| 12.3k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 12.3k| do { \ | | 925| 12.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 12.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 12.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 12.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 12.3k] | | ------------------ ------------------ 362| 12.3k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 12.3k| do { \ | | 925| 12.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 12.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 12.3k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 12.3k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 12.3k] | | ------------------ ------------------ 363| | 364| | /* full, allocate more storage */ 365| 12.3k| if (v->stor_end == v->end) { ------------------ | Branch (365:9): [True: 3.90k, False: 8.40k] ------------------ 366| 3.90k| igraph_int_t new_size = igraph_vector_ptr_size(v) * 2; 367| 3.90k| if (new_size == 0) { ------------------ | Branch (367:13): [True: 0, False: 3.90k] ------------------ 368| 0| new_size = 1; 369| 0| } 370| 3.90k| IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size)); ------------------ | | 656| 3.90k| do { \ | | 657| 3.90k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.90k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.90k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.90k] | | | | ------------------ | | ------------------ | | 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.90k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.90k] | | ------------------ ------------------ 371| 3.90k| } 372| | 373| 12.3k| *(v->end) = e; 374| 12.3k| v->end += 1; 375| | 376| 12.3k| return IGRAPH_SUCCESS; 377| 12.3k|} igraph_attribute_record_init: 126| 745|) { 127| 745| attr->name = NULL; 128| 745| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 129| 745| attr->value.as_raw = NULL; 130| 745| attr->default_value.string = NULL; 131| | 132| 745| IGRAPH_CHECK(igraph_attribute_record_set_name(attr, name)); ------------------ | | 656| 745| do { \ | | 657| 745| igraph_error_t igraph_i_ret = (expr); \ | | 658| 745| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 745| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 745] | | | | ------------------ | | ------------------ | | 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| 745| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 745] | | ------------------ ------------------ 133| 745| IGRAPH_FINALLY(igraph_free, attr->name); ------------------ | | 603| 745| do { \ | | 604| 745| /* the following branch makes the compiler check the compatibility of \ | | 605| 745| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 745| * incorrect destructor function with the pointer */ \ | | 607| 745| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 745] | | ------------------ | | 608| 745| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 745| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 745] | | ------------------ ------------------ 134| 745| IGRAPH_CHECK(igraph_attribute_record_set_type(attr, type)); ------------------ | | 656| 745| do { \ | | 657| 745| igraph_error_t igraph_i_ret = (expr); \ | | 658| 745| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 745| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 745] | | | | ------------------ | | ------------------ | | 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| 745| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 745] | | ------------------ ------------------ 135| 745| IGRAPH_FINALLY_CLEAN(1); 136| | 137| 745| return IGRAPH_SUCCESS; 138| 745|} igraph_attribute_record_destroy: 241| 745|void igraph_attribute_record_destroy(igraph_attribute_record_t *attr) { 242| 745| igraph_i_attribute_record_destroy_values(attr); 243| | 244| 745| if (attr->name) { ------------------ | Branch (244:9): [True: 745, False: 0] ------------------ 245| 745| igraph_free(attr->name); 246| | attr->name = NULL; 247| 745| } 248| 745|} igraph_attribute_record_size: 295| 638|igraph_int_t igraph_attribute_record_size(const igraph_attribute_record_t *attr) { 296| 638| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 638| do { \ | | 925| 638| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 638| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 638] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 638| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 638] | | ------------------ ------------------ 297| | 298| 638| switch (attr->type) { 299| 288| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (299:9): [True: 288, False: 350] ------------------ 300| 288| return igraph_vector_size(attr->value.as_vector); 301| | 302| 350| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (302:9): [True: 350, False: 288] ------------------ 303| 350| return igraph_strvector_size(attr->value.as_strvector); 304| | 305| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (305:9): [True: 0, False: 638] ------------------ 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: 638] ------------------ 309| 0| return 0; 310| | 311| 0| default: ------------------ | Branch (311:9): [True: 0, False: 638] ------------------ 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| 638| } 314| 638|} igraph_attribute_record_resize: 332| 138|) { 333| 138| igraph_int_t i; 334| 138| igraph_vector_t *vec; 335| 138| igraph_vector_bool_t *log; 336| 138| igraph_strvector_t *str; 337| | 338| 138| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 138| do { \ | | 925| 138| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 138] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 138| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 138] | | ------------------ ------------------ 339| | 340| 138| switch (attr->type) { 341| | 342| 0| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (342:9): [True: 0, False: 138] ------------------ 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: 138] ------------------ 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| 138| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (360:9): [True: 138, False: 0] ------------------ 361| 138| str = attr->value.as_strvector; 362| 138| if (attr->default_value.string == 0 || (*attr->default_value.string == 0)) { ------------------ | Branch (362:17): [True: 138, False: 0] | Branch (362:52): [True: 0, False: 0] ------------------ 363| 138| IGRAPH_CHECK(igraph_strvector_resize(str, new_size)); ------------------ | | 656| 138| do { \ | | 657| 138| igraph_error_t igraph_i_ret = (expr); \ | | 658| 138| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 138] | | | | ------------------ | | ------------------ | | 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| 138| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 138] | | ------------------ ------------------ 364| 138| } 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| 138| break; 372| | 373| 138| case IGRAPH_ATTRIBUTE_UNSPECIFIED: ------------------ | Branch (373:9): [True: 0, False: 138] ------------------ 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: 138] ------------------ 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| 138| } 380| | 381| 138| return IGRAPH_SUCCESS; 382| 138|} igraph_attribute_record_set_default_numeric: 399| 395|) { 400| 395| if (attr->type != IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (400:9): [True: 0, False: 395] ------------------ 401| 0| return IGRAPH_EINVAL; 402| 0| } 403| | 404| 395| attr->default_value.numeric = value; 405| 395| return IGRAPH_SUCCESS; 406| 395|} igraph_attribute_record_set_name: 483| 1.49k|) { 484| 1.49k| char *new_name; 485| | 486| 1.49k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.49k| do { \ | | 925| 1.49k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.49k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.49k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.49k] | | ------------------ ------------------ 487| | 488| 1.49k| if (name != NULL) { ------------------ | Branch (488:9): [True: 745, False: 745] ------------------ 489| 745| new_name = strdup(name); 490| 745| IGRAPH_CHECK_OOM(new_name, "Insufficient memory for allocating attribute name."); ------------------ | | 709| 745| do { \ | | 710| 745| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 745| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 745] | | | | ------------------ | | ------------------ | | 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| 745| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 745] | | ------------------ ------------------ 491| 745| } else { 492| 745| new_name = NULL; 493| 745| } 494| | 495| 1.49k| if (attr->name) { ------------------ | Branch (495:9): [True: 0, False: 1.49k] ------------------ 496| 0| igraph_free(attr->name); 497| 0| } 498| | 499| 1.49k| attr->name = new_name; 500| | 501| 1.49k| return IGRAPH_SUCCESS; 502| 1.49k|} igraph_attribute_record_set_type: 539| 1.49k|) { 540| 1.49k| void *ptr; 541| | 542| 1.49k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.49k| do { \ | | 925| 1.49k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.49k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.49k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.49k] | | ------------------ ------------------ 543| | 544| 1.49k| if (attr->type != type) { ------------------ | Branch (544:9): [True: 745, False: 745] ------------------ 545| 745| switch (type) { 546| 395| case IGRAPH_ATTRIBUTE_NUMERIC: { ------------------ | Branch (546:13): [True: 395, False: 350] ------------------ 547| 395| igraph_vector_t *vec = IGRAPH_CALLOC(1, igraph_vector_t); ------------------ | | 33| 395|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 790| (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: 395, Folded] | | | | ------------------ | | ------------------ ------------------ 548| 395| IGRAPH_CHECK_OOM(vec, "Insufficient memory for attribute record."); ------------------ | | 709| 395| do { \ | | 710| 395| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 395| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 395] | | | | ------------------ | | ------------------ | | 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| 395| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 395] | | ------------------ ------------------ 549| 395| IGRAPH_FINALLY(igraph_free, vec); ------------------ | | 603| 395| do { \ | | 604| 395| /* the following branch makes the compiler check the compatibility of \ | | 605| 395| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 395| * incorrect destructor function with the pointer */ \ | | 607| 395| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 395] | | ------------------ | | 608| 395| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 395| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 395] | | ------------------ ------------------ 550| 395| IGRAPH_VECTOR_INIT_FINALLY(vec, 0); ------------------ | | 104| 395| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 656| 395| do { \ | | | | 657| 395| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 395| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 395| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 395] | | | | | | ------------------ | | | | ------------------ | | | | 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| 395| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 395] | | | | ------------------ | | ------------------ | | 105| 395| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 603| 395| do { \ | | | | 604| 395| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 395| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 395| * incorrect destructor function with the pointer */ \ | | | | 607| 395| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 395] | | | | ------------------ | | | | 608| 395| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 395| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 395] | | | | ------------------ | | ------------------ | | | Branch (105:60): [Folded, False: 395] | | ------------------ ------------------ 551| 395| ptr = vec; 552| 395| } 553| 0| break; 554| | 555| 350| case IGRAPH_ATTRIBUTE_STRING: { ------------------ | Branch (555:13): [True: 350, False: 395] ------------------ 556| 350| igraph_strvector_t *strvec = IGRAPH_CALLOC(1, igraph_strvector_t); ------------------ | | 33| 350|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 700| (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: 350, Folded] | | | | ------------------ | | ------------------ ------------------ 557| 350| IGRAPH_CHECK_OOM(strvec, "Insufficient memory for attribute record."); ------------------ | | 709| 350| do { \ | | 710| 350| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 350| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 350] | | | | ------------------ | | ------------------ | | 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| 350| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 350] | | ------------------ ------------------ 558| 350| IGRAPH_FINALLY(igraph_free, strvec); ------------------ | | 603| 350| do { \ | | 604| 350| /* the following branch makes the compiler check the compatibility of \ | | 605| 350| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 350| * incorrect destructor function with the pointer */ \ | | 607| 350| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 350] | | ------------------ | | 608| 350| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 350| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 350] | | ------------------ ------------------ 559| 350| IGRAPH_STRVECTOR_INIT_FINALLY(strvec, 0); ------------------ | | 62| 350| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 350| do { \ | | | | 657| 350| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 350| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 350| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 350] | | | | | | ------------------ | | | | ------------------ | | | | 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| 350| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 350] | | | | ------------------ | | ------------------ | | 63| 350| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 350| do { \ | | | | 604| 350| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 350| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 350| * incorrect destructor function with the pointer */ \ | | | | 607| 350| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 350] | | | | ------------------ | | | | 608| 350| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 350| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 350] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 350] | | ------------------ ------------------ 560| 350| ptr = strvec; 561| 350| } 562| 0| break; 563| | 564| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: { ------------------ | Branch (564:13): [True: 0, False: 745] ------------------ 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: 745] ------------------ 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| 745| } 576| | 577| 745| igraph_i_attribute_record_set_type(attr, type, ptr); 578| 745| IGRAPH_FINALLY_CLEAN(2); 579| 745| } 580| | 581| 1.49k| return IGRAPH_SUCCESS; 582| 1.49k|} igraph_i_attribute_init: 617| 820|) { 618| 820| graph->attr = NULL; 619| 820| if (igraph_i_attribute_table) { ------------------ | Branch (619:9): [True: 820, False: 0] ------------------ 620| 820| IGRAPH_CHECK(igraph_i_attribute_table->init(graph, attr)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 621| 820| if (graph->attr == NULL) { ------------------ | Branch (621:13): [True: 0, False: 820] ------------------ 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| 820| } 625| 820| return IGRAPH_SUCCESS; 626| 820|} igraph_i_attribute_destroy: 628| 820|void igraph_i_attribute_destroy(igraph_t *graph) { 629| 820| if (graph->attr && igraph_i_attribute_table) { ------------------ | Branch (629:9): [True: 820, False: 0] | Branch (629:24): [True: 820, False: 0] ------------------ 630| 820| igraph_i_attribute_table->destroy(graph); 631| 820| } 632| | graph->attr = NULL; 633| 820|} igraph_i_attribute_add_vertices: 649| 1.64k|) { 650| 1.64k| if (igraph_i_attribute_table) { ------------------ | Branch (650:9): [True: 1.64k, False: 0] ------------------ 651| 1.64k| return igraph_i_attribute_table->add_vertices(graph, nv, attr); 652| 1.64k| } else { 653| 0| return IGRAPH_SUCCESS; 654| 0| } 655| 1.64k|} igraph_i_attribute_add_edges: 690| 496|) { 691| 496| if (igraph_i_attribute_table) { ------------------ | Branch (691:9): [True: 496, False: 0] ------------------ 692| 496| return igraph_i_attribute_table->add_edges(graph, edges, attr); 693| 496| } else { 694| 0| return IGRAPH_SUCCESS; 695| 0| } 696| 496|} igraph_set_attribute_table: 895| 2.33k|igraph_set_attribute_table(const igraph_attribute_table_t * table) { 896| 2.33k| igraph_attribute_table_t *old = igraph_i_attribute_table; 897| 2.33k| igraph_i_attribute_table = (igraph_attribute_table_t*) table; 898| 2.33k| return old; 899| 2.33k|} attributes.c:igraph_i_attribute_record_destroy_values: 185| 1.49k|static void igraph_i_attribute_record_destroy_values(igraph_attribute_record_t *attr) { 186| 1.49k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.49k| do { \ | | 925| 1.49k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.49k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.49k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.49k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.49k] | | ------------------ ------------------ 187| | 188| 1.49k| if (attr->value.as_raw) { ------------------ | Branch (188:9): [True: 745, False: 745] ------------------ 189| 745| switch (attr->type) { 190| 395| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (190:13): [True: 395, False: 350] ------------------ 191| 395| igraph_vector_destroy(attr->value.as_vector); 192| 395| break; 193| | 194| 350| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (194:13): [True: 350, False: 395] ------------------ 195| 350| igraph_strvector_destroy(attr->value.as_strvector); 196| 350| break; 197| | 198| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (198:13): [True: 0, False: 745] ------------------ 199| 0| igraph_vector_bool_destroy(attr->value.as_vector_bool); 200| 0| break; 201| | 202| 0| default: ------------------ | Branch (202:13): [True: 0, False: 745] ------------------ 203| 0| break; 204| 745| } 205| | 206| 745| igraph_free(attr->value.as_raw); 207| 745| attr->value.as_raw = NULL; 208| 745| } 209| | 210| 1.49k| switch (attr->type) { 211| 395| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (211:9): [True: 395, False: 1.09k] ------------------ 212| 395| attr->default_value.numeric = 0; 213| 395| break; 214| | 215| 350| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (215:9): [True: 350, False: 1.14k] ------------------ 216| 350| if (attr->default_value.string) { ------------------ | Branch (216:17): [True: 0, False: 350] ------------------ 217| 0| igraph_free(attr->default_value.string); 218| 0| attr->default_value.string = NULL; 219| 0| } 220| 350| break; 221| | 222| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (222:9): [True: 0, False: 1.49k] ------------------ 223| 0| attr->default_value.boolean = 0; 224| 0| break; 225| | 226| 745| default: ------------------ | Branch (226:9): [True: 745, False: 745] ------------------ 227| 745| break; 228| 1.49k| } 229| | 230| 1.49k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 231| 1.49k|} attributes.c:igraph_i_attribute_record_set_type: 506| 745|) { 507| 745| bool type_changed = attr->type != type; 508| | 509| 745| if (type_changed || attr->value.as_raw != ptr) { ------------------ | Branch (509:9): [True: 745, False: 0] | Branch (509:25): [True: 0, False: 0] ------------------ 510| 745| igraph_i_attribute_record_destroy_values(attr); 511| 745| attr->type = type; 512| 745| attr->value.as_raw = ptr; 513| 745| } 514| | 515| 745| if (type_changed && type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (515:9): [True: 745, False: 0] | Branch (515:25): [True: 395, False: 350] ------------------ 516| 395| IGRAPH_ASSERT( ------------------ | | 924| 395| do { \ | | 925| 395| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 395| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 395] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 395| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 395] | | ------------------ ------------------ 517| 395| igraph_attribute_record_set_default_numeric(attr, IGRAPH_NAN) == IGRAPH_SUCCESS 518| 395| ); 519| 395| } 520| 745|} attributes.c:igraph_i_attribute_record_list_init_item: 596| 745|) { 597| 745| IGRAPH_UNUSED(list); ------------------ | | 30| 745|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 598| | return igraph_attribute_record_init(item, NULL, IGRAPH_ATTRIBUTE_UNSPECIFIED); 599| 745|} attributes.c:igraph_i_attribute_record_list_destroy_item: 607| 745|static void igraph_i_attribute_record_list_destroy_item(igraph_attribute_record_t* item) { 608| 745| igraph_attribute_record_destroy(item); 609| 745|} igraph_i_property_cache_init: 32| 820|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) { 33| 820| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32); ------------------ | | 68| 820|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)])) ------------------ 34| | 35| 820| memset(cache->value, 0, sizeof(cache->value)); 36| 820| cache->known = 0; 37| 820| return IGRAPH_SUCCESS; 38| 820|} igraph_i_property_cache_destroy: 53| 820|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) { 54| 820| IGRAPH_UNUSED(cache); ------------------ | | 30| 820|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 55| | /* Nothing to do */ 56| 820|} igraph_i_property_cache_invalidate_conditionally: 182| 1.99k|) { 183| 1.99k| uint32_t invalidate = ~keep_always; 184| 1.99k| uint32_t mask; 185| 1.99k| uint32_t maybe_keep; 186| 1.99k| igraph_bool_t cached_value; 187| | 188| 1.99k| assert(graph->cache != NULL); ------------------ | Branch (188:5): [True: 0, False: 1.99k] | Branch (188:5): [True: 1.99k, 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| 1.99k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true); 197| | 198| 1.99k| if (maybe_keep) { ------------------ | Branch (198:9): [True: 0, False: 1.99k] ------------------ 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| 1.99k| graph->cache->known &= ~invalidate; 216| 1.99k|} cattributes.c:igraph_i_cattribute_init: 195| 820|) { 196| 820| igraph_i_cattributes_t *nattr; 197| | 198| 820| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t); ------------------ | | 33| 820|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 1.64k| (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: 820, Folded] | | | | ------------------ | | ------------------ ------------------ 199| 820| IGRAPH_CHECK_OOM(nattr, "Insufficient memory to allocate attribute storage."); ------------------ | | 709| 820| do { \ | | 710| 820| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 820] | | ------------------ ------------------ 200| 820| IGRAPH_FINALLY(igraph_free, nattr); ------------------ | | 603| 820| do { \ | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 820| * incorrect destructor function with the pointer */ \ | | 607| 820| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 820] | | ------------------ | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 820| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 820] | | ------------------ ------------------ 201| | 202| 820| if (attr) { ------------------ | Branch (202:9): [True: 0, False: 820] ------------------ 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| 820| } else { 205| 820| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->gal, 0)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 206| 820| } 207| 820| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->gal); ------------------ | | 603| 820| do { \ | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 820| * incorrect destructor function with the pointer */ \ | | 607| 820| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 820] | | ------------------ | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 820| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 820] | | ------------------ ------------------ 208| | 209| 820| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->val, 0)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 210| 820| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->val); ------------------ | | 603| 820| do { \ | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 820| * incorrect destructor function with the pointer */ \ | | 607| 820| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 820] | | ------------------ | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 820| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 820] | | ------------------ ------------------ 211| | 212| 820| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->eal, 0)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 213| 820| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->eal); ------------------ | | 603| 820| do { \ | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 820| * incorrect destructor function with the pointer */ \ | | 607| 820| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 820] | | ------------------ | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 820| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 820] | | ------------------ ------------------ 214| | 215| 820| graph->attr = nattr; 216| 820| IGRAPH_FINALLY_CLEAN(4); 217| | 218| 820| return IGRAPH_SUCCESS; 219| 820|} cattributes.c:igraph_i_cattribute_destroy: 221| 820|static void igraph_i_cattribute_destroy(igraph_t *graph) { 222| 820| igraph_i_cattributes_t *attr = graph->attr; 223| 820| igraph_attribute_record_list_destroy(&attr->eal); 224| 820| igraph_attribute_record_list_destroy(&attr->val); 225| 820| igraph_attribute_record_list_destroy(&attr->gal); 226| | IGRAPH_FREE(graph->attr); /* sets to NULL */ ------------------ | | 36| 820|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 227| 820|} cattributes.c:igraph_i_cattribute_add_vertices: 373| 1.64k|) { 374| 1.64k| igraph_i_cattributes_t *attr = graph->attr; 375| 1.64k| return igraph_i_cattribute_add_vertices_or_edges(&attr->val, igraph_vcount(graph), nv, nattr); 376| 1.64k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges: 344| 2.13k|) { 345| 2.13k| igraph_int_t origlen = newlen - nv; 346| 2.13k| igraph_error_t err = igraph_i_cattribute_add_vertices_or_edges_inner( 347| 2.13k| val, newlen, nv, nattr 348| 2.13k| ); 349| | 350| 2.13k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (350:9): [True: 138, False: 1.99k] ------------------ 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| 138| igraph_i_cattribute_revert_attribute_vector_sizes(val, origlen); 365| 138| } 366| | 367| 2.13k| return err; 368| 2.13k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges_inner: 269| 2.13k|) { 270| 2.13k| igraph_int_t length; 271| 2.13k| igraph_int_t nattrno = nattr == NULL ? 0 : igraph_attribute_record_list_size(nattr); ------------------ | Branch (271:28): [True: 1.81k, False: 319] ------------------ 272| 2.13k| igraph_int_t origlen = newlen - nv; 273| | 274| 2.13k| IGRAPH_ASSERT(origlen >= 0); ------------------ | | 924| 2.13k| do { \ | | 925| 2.13k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.13k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.13k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.13k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.13k] | | ------------------ ------------------ 275| | 276| | /* Find all the attributes that are newly added, and create new value vectors 277| | * for them in the original graph */ 278| 2.45k| for (igraph_int_t i = 0; i < nattrno; i++) { ------------------ | Branch (278:30): [True: 319, False: 2.13k] ------------------ 279| 319| const igraph_attribute_record_t *nattr_entry = igraph_attribute_record_list_get_ptr(nattr, i); 280| 319| const char *nname = nattr_entry->name; 281| 319| IGRAPH_CHECK(igraph_i_cattribute_find_or_create(val, nname, nattr_entry->type, origlen, NULL)); ------------------ | | 656| 319| do { \ | | 657| 319| igraph_error_t igraph_i_ret = (expr); \ | | 658| 319| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 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| 319| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 319] | | ------------------ ------------------ 282| 319| } 283| | 284| | /* Now append the new values */ 285| 2.13k| length = igraph_attribute_record_list_size(val); 286| 2.31k| for (igraph_int_t i = 0; i < length; i++) { ------------------ | Branch (286:30): [True: 319, False: 1.99k] ------------------ 287| 319| igraph_attribute_record_t *oldrec = igraph_attribute_record_list_get_ptr(val, i); 288| 319| const igraph_attribute_record_t *newrec = nattr ------------------ | Branch (288:51): [True: 319, False: 0] ------------------ 289| 319| ? igraph_i_cattribute_find_const(nattr, oldrec->name, oldrec->type) 290| 319| : NULL; 291| | 292| 319| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == origlen); ------------------ | | 924| 319| do { \ | | 925| 319| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 319| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 319] | | ------------------ ------------------ 293| | 294| 319| if (newrec) { ------------------ | Branch (294:13): [True: 319, False: 0] ------------------ 295| | /* This attribute is present in nattr */ 296| 319| switch (oldrec->type) { 297| 144| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (297:13): [True: 144, False: 175] ------------------ 298| 144| if (nv != igraph_vector_size(newrec->value.as_vector)) { ------------------ | Branch (298:21): [True: 0, False: 144] ------------------ 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| 144| IGRAPH_CHECK(igraph_vector_append( ------------------ | | 656| 144| do { \ | | 657| 144| igraph_error_t igraph_i_ret = (expr); \ | | 658| 144| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 144| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 144] | | | | ------------------ | | ------------------ | | 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| 144| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 144] | | ------------------ ------------------ 302| 144| oldrec->value.as_vector, newrec->value.as_vector 303| 144| )); 304| 144| break; 305| 175| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (305:13): [True: 175, False: 144] ------------------ 306| 175| if (nv != igraph_strvector_size(newrec->value.as_strvector)) { ------------------ | Branch (306:21): [True: 138, False: 37] ------------------ 307| 138| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL); ------------------ | | 426| 138| do { \ | | 427| 138| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 138| return igraph_errno ; \ | | 429| 138| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 308| 138| } 309| 37| IGRAPH_CHECK(igraph_strvector_append( ------------------ | | 656| 37| do { \ | | 657| 37| igraph_error_t igraph_i_ret = (expr); \ | | 658| 37| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 37| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 37] | | | | ------------------ | | ------------------ | | 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| 37| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 37] | | ------------------ ------------------ 310| 37| oldrec->value.as_strvector, newrec->value.as_strvector 311| 37| )); 312| 37| break; 313| 37| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (313:13): [True: 0, False: 319] ------------------ 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: 319] ------------------ 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| 319| } 328| 319| } 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| 181| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == newlen); ------------------ | | 924| 181| do { \ | | 925| 181| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 181| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 181] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 181| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 181] | | ------------------ ------------------ 335| 181| } 336| | 337| 1.99k| return IGRAPH_SUCCESS; 338| 2.13k|} cattributes.c:igraph_i_cattribute_find_const: 90| 319|) { 91| 319| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name); 92| 319| const igraph_attribute_record_t *rec; 93| | 94| 319| if (index >= 0) { ------------------ | Branch (94:9): [True: 319, False: 0] ------------------ 95| 319| rec = igraph_attribute_record_list_get_ptr(attrs, index); 96| 319| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) { ------------------ | Branch (96:13): [True: 0, False: 319] | Branch (96:53): [True: 319, False: 0] ------------------ 97| 319| return rec; 98| 319| } 99| 319| } 100| | 101| 0| return NULL; 102| 319|} cattributes.c:igraph_i_cattribute_revert_attribute_vector_sizes: 179| 138| igraph_attribute_record_list_t *attrlist, igraph_int_t origlen) { 180| | 181| 138| igraph_int_t no_of_attrs = igraph_attribute_record_list_size(attrlist); 182| 276| for (igraph_int_t i = 0; i < no_of_attrs; i++) { ------------------ | Branch (182:30): [True: 138, False: 138] ------------------ 183| 138| igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrlist, i); 184| 138| IGRAPH_ASSERT(igraph_attribute_record_size(rec) >= origlen); ------------------ | | 924| 138| do { \ | | 925| 138| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 138| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 138] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 138| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 138] | | ------------------ ------------------ 185| 138| if (igraph_attribute_record_resize(rec, origlen) != IGRAPH_SUCCESS) { ------------------ | Branch (185:13): [True: 0, False: 138] ------------------ 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| 138| } 191| 138|} cattributes.c:igraph_i_cattribute_add_edges: 1463| 496|) { 1464| 496| igraph_int_t ne = igraph_vector_int_size(edges) / 2; 1465| 496| igraph_i_cattributes_t *attr = graph->attr; 1466| 496| return igraph_i_cattribute_add_vertices_or_edges(&attr->eal, igraph_ecount(graph), ne, nattr); 1467| 496|} cattributes.c:igraph_i_cattribute_find: 69| 319|) { 70| 319| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name); 71| 319| igraph_attribute_record_t *rec; 72| | 73| 319| if (index >= 0) { ------------------ | Branch (73:9): [True: 0, False: 319] ------------------ 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| 319| return NULL; 81| 319|} cattributes.c:igraph_i_cattribute_find_or_create: 147| 319|) { 148| 319| igraph_attribute_record_t *rec; 149| | 150| 319| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED); 151| 319| if (rec) { ------------------ | Branch (151:9): [True: 0, False: 319] ------------------ 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| 319| } else { 156| 319| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(attrs, &rec)); ------------------ | | 656| 319| do { \ | | 657| 319| igraph_error_t igraph_i_ret = (expr); \ | | 658| 319| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 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| 319| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 319] | | ------------------ ------------------ 157| 319| IGRAPH_CHECK(igraph_attribute_record_set_name(rec, name)); ------------------ | | 656| 319| do { \ | | 657| 319| igraph_error_t igraph_i_ret = (expr); \ | | 658| 319| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 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| 319| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 319] | | ------------------ ------------------ 158| 319| IGRAPH_CHECK(igraph_attribute_record_set_type(rec, type)); ------------------ | | 656| 319| do { \ | | 657| 319| igraph_error_t igraph_i_ret = (expr); \ | | 658| 319| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 319| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 319] | | | | ------------------ | | ------------------ | | 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| 319| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 319] | | ------------------ ------------------ 159| 319| } 160| | 161| 319| if (length > 0 && igraph_attribute_record_size(rec) < length) { ------------------ | Branch (161:9): [True: 0, False: 319] | 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| 319| if (ptr) { ------------------ | Branch (165:9): [True: 0, False: 319] ------------------ 166| 0| *ptr = rec; 167| 0| } 168| | 169| 319| return IGRAPH_SUCCESS; 170| 319|} cattributes.c:igraph_i_cattribute_find_index: 49| 638|) { 50| 638| igraph_int_t n = igraph_attribute_record_list_size(attrs); 51| 638| for (igraph_int_t i = 0; i < n; i++) { ------------------ | Branch (51:30): [True: 319, False: 319] ------------------ 52| 319| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrs, i); 53| 319| if (!strcmp(rec->name, name)) { ------------------ | Branch (53:13): [True: 319, False: 0] ------------------ 54| 319| return i; 55| 319| } 56| 319| } 57| 319| return -1; 58| 638|} igraph_empty: 64| 820|igraph_error_t igraph_empty(igraph_t *graph, igraph_int_t n, igraph_bool_t directed) { 65| 820| return igraph_empty_attrs(graph, n, directed, 0); 66| 820|} igraph_empty_attrs: 102| 820|) { 103| | 104| 820| if (n < 0) { ------------------ | Branch (104:9): [True: 0, False: 820] ------------------ 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| 820| memset(graph, 0, sizeof(igraph_t)); 109| | 110| 820| graph->n = 0; 111| 820| graph->directed = directed; 112| 820| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0); ------------------ | | 119| 820| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 820| do { \ | | | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 820] | | | | | | ------------------ | | | | ------------------ | | | | 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| 820| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | 120| 820| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 820| do { \ | | | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 820| * incorrect destructor function with the pointer */ \ | | | | 607| 820| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 820] | | | | ------------------ | | | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 820| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 820] | | ------------------ ------------------ 113| 820| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0); ------------------ | | 119| 820| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 820| do { \ | | | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 820] | | | | | | ------------------ | | | | ------------------ | | | | 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| 820| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | 120| 820| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 820| do { \ | | | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 820| * incorrect destructor function with the pointer */ \ | | | | 607| 820| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 820] | | | | ------------------ | | | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 820| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 820] | | ------------------ ------------------ 114| 820| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0); ------------------ | | 119| 820| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 820| do { \ | | | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 820] | | | | | | ------------------ | | | | ------------------ | | | | 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| 820| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | 120| 820| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 820| do { \ | | | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 820| * incorrect destructor function with the pointer */ \ | | | | 607| 820| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 820] | | | | ------------------ | | | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 820| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 820] | | ------------------ ------------------ 115| 820| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0); ------------------ | | 119| 820| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 820| do { \ | | | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 820] | | | | | | ------------------ | | | | ------------------ | | | | 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| 820| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | 120| 820| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 820| do { \ | | | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 820| * incorrect destructor function with the pointer */ \ | | | | 607| 820| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 820] | | | | ------------------ | | | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 820| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 820] | | ------------------ ------------------ 116| 820| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1); ------------------ | | 119| 820| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 820| do { \ | | | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 820] | | | | | | ------------------ | | | | ------------------ | | | | 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| 820| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | 120| 820| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 820| do { \ | | | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 820| * incorrect destructor function with the pointer */ \ | | | | 607| 820| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 820] | | | | ------------------ | | | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 820| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 820] | | ------------------ ------------------ 117| 820| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1); ------------------ | | 119| 820| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 820| do { \ | | | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 820] | | | | | | ------------------ | | | | ------------------ | | | | 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| 820| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | 120| 820| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 820| do { \ | | | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 820| * incorrect destructor function with the pointer */ \ | | | | 607| 820| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 820] | | | | ------------------ | | | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 820| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 820] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 820] | | ------------------ ------------------ 118| | 119| | /* init cache */ 120| 820| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 33| 820|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 1.64k| (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: 820, Folded] | | | | ------------------ | | ------------------ ------------------ 121| 820| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph."); ------------------ | | 709| 820| do { \ | | 710| 820| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 820] | | ------------------ ------------------ 122| 820| IGRAPH_FINALLY(igraph_free, graph->cache); ------------------ | | 603| 820| do { \ | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 820| * incorrect destructor function with the pointer */ \ | | 607| 820| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 820] | | ------------------ | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 820| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 820] | | ------------------ ------------------ 123| 820| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 124| 820| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache); ------------------ | | 603| 820| do { \ | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 820| * incorrect destructor function with the pointer */ \ | | 607| 820| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 820] | | ------------------ | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 820| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 820] | | ------------------ ------------------ 125| | 126| 820| VECTOR(graph->os)[0] = 0; ------------------ | | 60| 820|#define VECTOR(v) ((v).stor_begin) ------------------ 127| 820| VECTOR(graph->is)[0] = 0; ------------------ | | 60| 820|#define VECTOR(v) ((v).stor_begin) ------------------ 128| | 129| | /* init attributes */ 130| 820| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 131| | 132| | /* add the vertices */ 133| 820| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 134| | 135| 820| IGRAPH_FINALLY_CLEAN(8); 136| 820| return IGRAPH_SUCCESS; 137| 820|} igraph_destroy: 155| 820|void igraph_destroy(igraph_t *graph) { 156| 820| igraph_i_attribute_destroy(graph); 157| | 158| 820| igraph_i_property_cache_destroy(graph->cache); 159| 820| IGRAPH_FREE(graph->cache); ------------------ | | 36| 820|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 160| | 161| 820| igraph_vector_int_destroy(&graph->from); 162| 820| igraph_vector_int_destroy(&graph->to); 163| 820| igraph_vector_int_destroy(&graph->oi); 164| 820| igraph_vector_int_destroy(&graph->ii); 165| 820| igraph_vector_int_destroy(&graph->os); 166| 820| igraph_vector_int_destroy(&graph->is); 167| 820|} igraph_add_edges: 257| 682|) { 258| 682| igraph_int_t no_of_edges = igraph_vector_int_size(&graph->from); 259| 682| igraph_int_t edges_to_add = igraph_vector_int_size(edges) / 2; 260| 682| igraph_int_t new_no_of_edges; 261| 682| igraph_int_t i = 0; 262| 682| igraph_vector_int_t newoi, newii; 263| 682| igraph_bool_t directed = igraph_is_directed(graph); 264| | 265| 682| if (igraph_vector_int_size(edges) % 2 != 0) { ------------------ | Branch (265:9): [True: 0, False: 682] ------------------ 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| 682| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) { ------------------ | Branch (268:9): [True: 186, False: 496] ------------------ 269| 186| IGRAPH_ERROR("Out-of-range vertex IDs when adding edges.", IGRAPH_EINVVID); ------------------ | | 426| 186| do { \ | | 427| 186| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 186| return igraph_errno ; \ | | 429| 186| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 270| 186| } 271| | 272| | /* from & to */ 273| 496| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges); ------------------ | | 47| 496| do { \ | | 48| 496| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 496| igraph_int_t _safe_sum; \ | | 50| 496| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 496] | | ------------------ | | 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| 496| *(res) = _safe_sum; \ | | 54| 496| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 496] | | ------------------ ------------------ 274| 496| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) { ------------------ | | 118| 496|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2) | | ------------------ | | | | 72| 496|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (274:9): [True: 0, False: 496] ------------------ 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| 496| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add)); ------------------ | | 656| 496| do { \ | | 657| 496| igraph_error_t igraph_i_ret = (expr); \ | | 658| 496| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 496| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 496] | | | | ------------------ | | ------------------ | | 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| 496| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 496] | | ------------------ ------------------ 279| 496| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add)); ------------------ | | 656| 496| do { \ | | 657| 496| igraph_error_t igraph_i_ret = (expr); \ | | 658| 496| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 496| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 496] | | | | ------------------ | | ------------------ | | 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| 496| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 496] | | ------------------ ------------------ 280| | 281| 3.16M| while (i < edges_to_add * 2) { ------------------ | Branch (281:12): [True: 3.16M, False: 496] ------------------ 282| 3.16M| 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.16M, False: 0] | Branch (282:25): [True: 0, False: 0] ------------------ 283| 3.16M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 60| 3.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 284| 3.16M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 60| 3.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 285| 3.16M| } 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.16M| } 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| 496|#define CHECK_ERR(expr) \ 299| 496| do { \ 300| 496| igraph_error_t err = (expr); \ 301| 496| if (err != IGRAPH_SUCCESS) { \ 302| 496| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ 303| 496| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ 304| 496| IGRAPH_FINALLY_EXIT(); \ 305| 496| IGRAPH_ERROR("Cannot add edges.", err); \ 306| 496| } \ 307| 496| } while (0) 308| | 309| | /* oi & ii */ 310| 496| IGRAPH_FINALLY_ENTER(); 311| 496| { 312| 496| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges)); ------------------ | | 299| 496| do { \ | | 300| 496| igraph_error_t err = (expr); \ | | 301| 496| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 496] | | ------------------ | | 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| 496| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 496] | | ------------------ ------------------ 313| 496| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi); ------------------ | | 603| 496| do { \ | | 604| 496| /* the following branch makes the compiler check the compatibility of \ | | 605| 496| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 496| * incorrect destructor function with the pointer */ \ | | 607| 496| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 496] | | ------------------ | | 608| 496| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 496| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 496] | | ------------------ ------------------ 314| 496| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges)); ------------------ | | 299| 496| do { \ | | 300| 496| igraph_error_t err = (expr); \ | | 301| 496| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 496] | | ------------------ | | 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| 496| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 496] | | ------------------ ------------------ 315| 496| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii); ------------------ | | 603| 496| do { \ | | 604| 496| /* the following branch makes the compiler check the compatibility of \ | | 605| 496| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 496| * incorrect destructor function with the pointer */ \ | | 607| 496| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 496] | | ------------------ | | 608| 496| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 496| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 496] | | ------------------ ------------------ 316| 496| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n)); ------------------ | | 299| 496| do { \ | | 300| 496| igraph_error_t err = (expr); \ | | 301| 496| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 496] | | ------------------ | | 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| 496| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 496] | | ------------------ ------------------ 317| 496| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n)); ------------------ | | 299| 496| do { \ | | 300| 496| igraph_error_t err = (expr); \ | | 301| 496| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 496] | | ------------------ | | 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| 496| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 496] | | ------------------ ------------------ 318| | 319| | /* Attributes */ 320| 496| if (graph->attr) { ------------------ | Branch (320:13): [True: 496, False: 0] ------------------ 321| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */ 322| 496| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr)); ------------------ | | 299| 496| do { \ | | 300| 496| igraph_error_t err = (expr); \ | | 301| 496| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 496] | | ------------------ | | 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| 496| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 496] | | ------------------ ------------------ 323| 496| } 324| | 325| | /* os & is, its length does not change, error safe */ 326| 496| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n); 327| 496| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n); 328| | 329| | /* everything went fine */ 330| 496| igraph_vector_int_destroy(&graph->oi); 331| 496| igraph_vector_int_destroy(&graph->ii); 332| 496| IGRAPH_FINALLY_CLEAN(2); 333| | 334| 496| graph->oi = newoi; 335| 496| graph->ii = newii; 336| 496| } 337| 0| IGRAPH_FINALLY_EXIT(); 338| | 339| 496|#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| 496| igraph_i_property_cache_invalidate_conditionally( 354| 496| graph, 355| 496| /* keep_always = */ 0, 356| | /* keep_when_false = */ 357| 496| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST), 358| | /* keep_when_true = */ 359| 496| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) | 360| 496| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 361| 496| (1 << IGRAPH_PROP_HAS_LOOP) | 362| 496| (1 << IGRAPH_PROP_HAS_MULTI) | 363| 496| (1 << IGRAPH_PROP_HAS_MUTUAL) 364| 496| ); 365| | 366| 496| return IGRAPH_SUCCESS; 367| 496|} igraph_add_vertices: 391| 1.64k|) { 392| 1.64k| igraph_int_t ec = igraph_ecount(graph); 393| 1.64k| igraph_int_t vc = igraph_vcount(graph); 394| 1.64k| igraph_int_t new_vc; 395| 1.64k| igraph_int_t i; 396| | 397| 1.64k| if (nv < 0) { ------------------ | Branch (397:9): [True: 0, False: 1.64k] ------------------ 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.64k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc); ------------------ | | 47| 1.64k| do { \ | | 48| 1.64k| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 1.64k| igraph_int_t _safe_sum; \ | | 50| 1.64k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 1.64k] | | ------------------ | | 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.64k| *(res) = _safe_sum; \ | | 54| 1.64k| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 1.64k] | | ------------------ ------------------ 402| 1.64k| if (new_vc > IGRAPH_VCOUNT_MAX) { ------------------ | | 100| 1.64k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1) | | ------------------ | | | | 72| 1.64k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (402:9): [True: 0, False: 1.64k] ------------------ 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.64k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1)); ------------------ | | 656| 1.64k| do { \ | | 657| 1.64k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.64k] | | | | ------------------ | | ------------------ | | 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.64k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.64k] | | ------------------ ------------------ 407| 1.64k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1)); ------------------ | | 656| 1.64k| do { \ | | 657| 1.64k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.64k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.64k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.64k] | | | | ------------------ | | ------------------ | | 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.64k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.64k] | | ------------------ ------------------ 408| | 409| 1.64k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */ 410| 1.64k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */ 411| 102M| for (i = graph->n + 1; i < new_vc + 1; i++) { ------------------ | Branch (411:28): [True: 102M, False: 1.64k] ------------------ 412| 102M| VECTOR(graph->os)[i] = ec; ------------------ | | 60| 102M|#define VECTOR(v) ((v).stor_begin) ------------------ 413| 102M| VECTOR(graph->is)[i] = ec; ------------------ | | 60| 102M|#define VECTOR(v) ((v).stor_begin) ------------------ 414| 102M| } 415| | 416| 1.64k| 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.64k| if (graph->attr) { ------------------ | Branch (422:9): [True: 1.64k, False: 0] ------------------ 423| 1.64k| igraph_error_t err; 424| 1.64k| IGRAPH_FINALLY_ENTER(); 425| 1.64k| err = igraph_i_attribute_add_vertices(graph, nv, attr); 426| 1.64k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (426:13): [True: 138, False: 1.50k] ------------------ 427| | /* Restore original vertex count on failure */ 428| 138| graph->n = vc; 429| 138| igraph_vector_int_resize(&graph->os, vc + 1); /* shrinks */ 430| 138| igraph_vector_int_resize(&graph->is, vc + 1); /* shrinks */ 431| 138| } 432| 1.64k| IGRAPH_FINALLY_EXIT(); 433| 1.64k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (433:13): [True: 138, False: 1.50k] ------------------ 434| 138| IGRAPH_ERROR("Cannot add vertices.", err); ------------------ | | 426| 138| do { \ | | 427| 138| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 138| return igraph_errno ; \ | | 429| 138| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 435| 138| } 436| 1.64k| } 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.50k| igraph_i_property_cache_invalidate_conditionally( 458| 1.50k| graph, 459| | /* keep_always = */ 460| 1.50k| (1 << IGRAPH_PROP_HAS_LOOP) | 461| 1.50k| (1 << IGRAPH_PROP_HAS_MULTI) | 462| 1.50k| (1 << IGRAPH_PROP_HAS_MUTUAL) | 463| 1.50k| (1 << IGRAPH_PROP_IS_DAG) | 464| 1.50k| (1 << IGRAPH_PROP_IS_FOREST), 465| | /* keep_when_false = */ 466| 1.50k| igraph_vcount(graph) >= 2 ? ( ------------------ | Branch (466:9): [True: 619, False: 883] ------------------ 467| 619| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 468| 619| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) 469| 883| ) : 0, 470| | /* keep_when_true = */ 471| 1.50k| 0 472| 1.50k| ); 473| | 474| 1.50k| return IGRAPH_SUCCESS; 475| 1.64k|} igraph_vcount: 829| 5.46k|igraph_int_t igraph_vcount(const igraph_t *graph) { 830| 5.46k| return graph->n; 831| 5.46k|} igraph_ecount: 843| 2.13k|igraph_int_t igraph_ecount(const igraph_t *graph) { 844| 2.13k| return igraph_vector_int_size(&graph->from); 845| 2.13k|} igraph_is_directed: 1133| 682|igraph_bool_t igraph_is_directed(const igraph_t *graph) { 1134| 682| return graph->directed; 1135| 682|} type_indexededgelist.c:igraph_i_create_start_vectors: 1076| 992| igraph_vector_int_t *iindex, igraph_int_t nodes) { 1077| | 1078| 992|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) 1079| | 1080| 992| igraph_int_t no_of_nodes; 1081| 992| igraph_int_t no_of_edges; 1082| 992| igraph_int_t i, j, idx; 1083| | 1084| 992| no_of_nodes = nodes; 1085| 992| no_of_edges = igraph_vector_int_size(el); 1086| | 1087| | /* result */ 1088| | 1089| 992| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1)); ------------------ | | 656| 992| do { \ | | 657| 992| igraph_error_t igraph_i_ret = (expr); \ | | 658| 992| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 992| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 992] | | | | ------------------ | | ------------------ | | 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| 992| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 992] | | ------------------ ------------------ 1090| | 1091| | /* create the index */ 1092| | 1093| 992| if (no_of_edges == 0) { ------------------ | Branch (1093:9): [True: 306, False: 686] ------------------ 1094| | /* empty graph */ 1095| 306| igraph_vector_int_null(res); 1096| 686| } else { 1097| 686| idx = -1; 1098| 3.28M| for (i = 0; i <= EDGE(0); i++) { ------------------ | | 1078| 3.28M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 3.28M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 3.28M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (1098:21): [True: 3.28M, False: 686] ------------------ 1099| 3.28M| idx++; VECTOR(*res)[idx] = 0; ------------------ | | 60| 3.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 1100| 3.28M| } 1101| 6.32M| for (i = 1; i < no_of_edges; i++) { ------------------ | Branch (1101:21): [True: 6.32M, False: 686] ------------------ 1102| 6.32M| igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1078| 6.32M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ igraph_int_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1078| 6.32M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 6.32M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1103| 10.4M| for (j = 0; j < n; j++) { ------------------ | Branch (1103:25): [True: 4.16M, False: 6.32M] ------------------ 1104| 4.16M| idx++; VECTOR(*res)[idx] = i; ------------------ | | 60| 4.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 1105| 4.16M| } 1106| 6.32M| } 1107| 686| j = EDGE(VECTOR(*res)[idx]); ------------------ | | 1078| 686|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 686|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 686|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1108| 20.9M| for (i = 0; i < no_of_nodes - j; i++) { ------------------ | Branch (1108:21): [True: 20.9M, False: 686] ------------------ 1109| 20.9M| idx++; VECTOR(*res)[idx] = no_of_edges; ------------------ | | 60| 20.9M|#define VECTOR(v) ((v).stor_begin) ------------------ 1110| 20.9M| } 1111| 686| } 1112| | 1113| | /* clean */ 1114| | 1115| 992|# undef EDGE 1116| 992| return IGRAPH_SUCCESS; 1117| 992|} igraph_dl_yylex_destroy_wrapper: 37| 1.84k|void igraph_dl_yylex_destroy_wrapper (void *scanner ) { 38| 1.84k| (void) igraph_dl_yylex_destroy(scanner); 39| 1.84k|} igraph_read_graph_dl: 68| 2.33k| igraph_bool_t directed) { 69| | 70| 2.33k| igraph_int_t n, n2; 71| 2.33k| const igraph_strvector_t *namevec = 0; 72| 2.33k| igraph_attribute_record_list_t name, weight; 73| 2.33k| igraph_attribute_record_list_t *pname = NULL; 74| 2.33k| igraph_attribute_record_list_t *pweight = NULL; 75| 2.33k| igraph_attribute_record_t *namerec, *weightrec; 76| 2.33k| const char *namestr = "name", *weightstr = "weight"; 77| 2.33k| igraph_i_dl_parsedata_t context; 78| | 79| 2.33k| context.eof = 0; 80| 2.33k| context.mode = 0; 81| 2.33k| context.n = -1; 82| 2.33k| context.from = 0; 83| 2.33k| context.to = 0; 84| 2.33k| context.errmsg[0] = '\0'; 85| 2.33k| context.igraph_errno = IGRAPH_SUCCESS; 86| | 87| 2.33k| IGRAPH_VECTOR_INT_INIT_FINALLY(&context.edges, 0); ------------------ | | 119| 2.33k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 2.33k| do { \ | | | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 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.33k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | 120| 2.33k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 2.33k| do { \ | | | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.33k] | | | | ------------------ | | | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 2.33k] | | ------------------ ------------------ 88| 2.33k| IGRAPH_VECTOR_INIT_FINALLY(&context.weights, 0); ------------------ | | 104| 2.33k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 656| 2.33k| do { \ | | | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 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.33k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | 105| 2.33k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 603| 2.33k| do { \ | | | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.33k] | | | | ------------------ | | | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | | Branch (105:60): [Folded, False: 2.33k] | | ------------------ ------------------ 89| 2.33k| IGRAPH_CHECK(igraph_strvector_init(&context.labels, 0)); ------------------ | | 656| 2.33k| do { \ | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | ------------------ | | ------------------ | | 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.33k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.33k] | | ------------------ ------------------ 90| 2.33k| IGRAPH_FINALLY(igraph_strvector_destroy, &context.labels); ------------------ | | 603| 2.33k| do { \ | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | 607| 2.33k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.33k] | | ------------------ | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.33k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.33k] | | ------------------ ------------------ 91| 2.33k| IGRAPH_TRIE_INIT_FINALLY(&context.trie, /*names=*/ 1); ------------------ | | 55| 2.33k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \ | | ------------------ | | | | 656| 2.33k| do { \ | | | | 657| 2.33k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.33k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.33k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.33k] | | | | | | ------------------ | | | | ------------------ | | | | 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.33k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | 56| 2.33k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0) | | ------------------ | | | | 603| 2.33k| do { \ | | | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.33k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.33k] | | | | ------------------ | | | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.33k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.33k] | | | | ------------------ | | ------------------ | | | Branch (56:59): [Folded, False: 2.33k] | | ------------------ ------------------ 92| | 93| 2.33k| igraph_dl_yylex_init_extra(&context, &context.scanner); 94| 2.33k| IGRAPH_FINALLY(igraph_dl_yylex_destroy_wrapper, context.scanner); ------------------ | | 603| 2.33k| do { \ | | 604| 2.33k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.33k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.33k| * incorrect destructor function with the pointer */ \ | | 607| 2.33k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.33k] | | ------------------ | | 608| 2.33k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.33k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.33k] | | ------------------ ------------------ 95| | 96| 2.33k| igraph_dl_yyset_in(instream, context.scanner); 97| | 98| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */ 99| 2.33k| IGRAPH_FINALLY_ENTER(); 100| 2.33k| int err = igraph_dl_yyparse(&context); 101| 2.33k| IGRAPH_FINALLY_EXIT(); 102| 2.33k| switch (err) { 103| 820| case 0: /* success */ ------------------ | Branch (103:5): [True: 820, False: 1.51k] ------------------ 104| 820| break; 105| 1.51k| case 1: /* parse error */ ------------------ | Branch (105:5): [True: 1.51k, False: 820] ------------------ 106| 1.51k| if (context.errmsg[0] != 0) { ------------------ | Branch (106:13): [True: 1.46k, False: 51] ------------------ 107| 1.46k| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR); ------------------ | | 426| 1.46k| do { \ | | 427| 1.46k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 1.46k| return igraph_errno ; \ | | 429| 1.46k| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 108| 1.46k| } else if (context.igraph_errno != IGRAPH_SUCCESS) { ------------------ | Branch (108:20): [True: 51, False: 0] ------------------ 109| 51| IGRAPH_ERROR("", context.igraph_errno); ------------------ | | 426| 51| do { \ | | 427| 51| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 51| return igraph_errno ; \ | | 429| 51| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 110| 51| } 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.33k] ------------------ 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.33k] ------------------ 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.33k| } 125| | 126| | /* Extend the weight vector, if needed */ 127| 820| n = igraph_vector_size(&context.weights); 128| 820| n2 = igraph_vector_int_size(&context.edges) / 2; 129| 820| if (n != 0) { ------------------ | Branch (129:9): [True: 251, False: 569] ------------------ 130| 251| IGRAPH_CHECK(igraph_vector_resize(&context.weights, n2)); ------------------ | | 656| 251| do { \ | | 657| 251| igraph_error_t igraph_i_ret = (expr); \ | | 658| 251| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 251| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 251] | | | | ------------------ | | ------------------ | | 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| 251| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 251] | | ------------------ ------------------ 131| 8.94k| for (; n < n2; n++) { ------------------ | Branch (131:16): [True: 8.69k, False: 251] ------------------ 132| 8.69k| VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 60| 8.69k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 138| 8.69k|#define IGRAPH_NAN ((double)NAN) ------------------ 133| 8.69k| } 134| 251| } 135| | 136| | /* Check number of vertices */ 137| 820| if (n2 > 0) { ------------------ | Branch (137:9): [True: 587, False: 233] ------------------ 138| 587| n = igraph_vector_int_max(&context.edges); 139| 587| } else { 140| 233| n = 0; 141| 233| } 142| 820| if (n >= context.n) { ------------------ | Branch (142:9): [True: 296, False: 524] ------------------ 143| 296| IGRAPH_WARNING("More vertices than specified in `DL' file"); ------------------ | | 797| 296| do { \ | | 798| 296| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 799| 296| } while (0) | | ------------------ | | | Branch (799:14): [Folded, False: 296] | | ------------------ ------------------ 144| 296| context.n = n; 145| 296| } 146| | 147| | /* Prepare attributes */ 148| | 149| | /* Labels */ 150| 820| if (igraph_strvector_size(&context.labels) != 0) { ------------------ | Branch (150:9): [True: 99, False: 721] ------------------ 151| 99| namevec = (const igraph_strvector_t*) &context.labels; 152| 721| } else if (igraph_trie_size(&context.trie) != 0) { ------------------ | Branch (152:16): [True: 76, False: 645] ------------------ 153| 76| namevec = igraph_i_trie_borrow_keys(&context.trie); 154| 76| } 155| 820| if (namevec) { ------------------ | Branch (155:9): [True: 175, False: 645] ------------------ 156| 175| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1)); ------------------ | | 656| 175| do { \ | | 657| 175| igraph_error_t igraph_i_ret = (expr); \ | | 658| 175| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 175| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 175] | | | | ------------------ | | ------------------ | | 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| 175| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 175] | | ------------------ ------------------ 157| 175| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name); ------------------ | | 603| 175| do { \ | | 604| 175| /* the following branch makes the compiler check the compatibility of \ | | 605| 175| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 175| * incorrect destructor function with the pointer */ \ | | 607| 175| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 175] | | ------------------ | | 608| 175| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 175| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 175] | | ------------------ ------------------ 158| | 159| 175| namerec = igraph_attribute_record_list_get_ptr(&name, 0); 160| 175| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr)); ------------------ | | 656| 175| do { \ | | 657| 175| igraph_error_t igraph_i_ret = (expr); \ | | 658| 175| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 175| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 175] | | | | ------------------ | | ------------------ | | 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| 175| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 175] | | ------------------ ------------------ 161| 175| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING)); ------------------ | | 656| 175| do { \ | | 657| 175| igraph_error_t igraph_i_ret = (expr); \ | | 658| 175| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 175| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 175] | | | | ------------------ | | ------------------ | | 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| 175| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 175] | | ------------------ ------------------ 162| 175| IGRAPH_CHECK(igraph_strvector_update(namerec->value.as_strvector, namevec)); ------------------ | | 656| 175| do { \ | | 657| 175| igraph_error_t igraph_i_ret = (expr); \ | | 658| 175| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 175| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 175] | | | | ------------------ | | ------------------ | | 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| 175| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 175] | | ------------------ ------------------ 163| | 164| 175| pname = &name; 165| 175| } 166| | 167| | /* Weights */ 168| 820| if (igraph_vector_size(&context.weights) != 0) { ------------------ | Branch (168:9): [True: 251, False: 569] ------------------ 169| 251| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1)); ------------------ | | 656| 251| do { \ | | 657| 251| igraph_error_t igraph_i_ret = (expr); \ | | 658| 251| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 251| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 251] | | | | ------------------ | | ------------------ | | 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| 251| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 251] | | ------------------ ------------------ 170| 251| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight); ------------------ | | 603| 251| do { \ | | 604| 251| /* the following branch makes the compiler check the compatibility of \ | | 605| 251| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 251| * incorrect destructor function with the pointer */ \ | | 607| 251| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 251] | | ------------------ | | 608| 251| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 251| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 251] | | ------------------ ------------------ 171| | 172| 251| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0); 173| 251| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr)); ------------------ | | 656| 251| do { \ | | 657| 251| igraph_error_t igraph_i_ret = (expr); \ | | 658| 251| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 251| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 251] | | | | ------------------ | | ------------------ | | 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| 251| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 251] | | ------------------ ------------------ 174| 251| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC)); ------------------ | | 656| 251| do { \ | | 657| 251| igraph_error_t igraph_i_ret = (expr); \ | | 658| 251| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 251| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 251] | | | | ------------------ | | ------------------ | | 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| 251| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 251] | | ------------------ ------------------ 175| 251| igraph_vector_swap(weightrec->value.as_vector, &context.weights); 176| | 177| 251| pweight = &weight; 178| 251| } 179| | 180| | /* Create graph */ 181| 820| IGRAPH_CHECK(igraph_empty(graph, 0, directed)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 820] | | | | ------------------ | | ------------------ | | 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| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 820] | | ------------------ ------------------ 182| 820| IGRAPH_FINALLY(igraph_destroy, graph); ------------------ | | 603| 820| do { \ | | 604| 820| /* the following branch makes the compiler check the compatibility of \ | | 605| 820| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 820| * incorrect destructor function with the pointer */ \ | | 607| 820| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 820] | | ------------------ | | 608| 820| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 820| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 820] | | ------------------ ------------------ 183| 820| IGRAPH_CHECK(igraph_add_vertices(graph, context.n, pname)); ------------------ | | 656| 820| do { \ | | 657| 820| igraph_error_t igraph_i_ret = (expr); \ | | 658| 820| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 820| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 138, False: 682] | | | | ------------------ | | ------------------ | | 659| 138| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 138| do { \ | | | | 427| 138| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 138| return igraph_errno ; \ | | | | 429| 138| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 138| } \ | | 661| 820| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 682] | | ------------------ ------------------ 184| 682| IGRAPH_CHECK(igraph_add_edges(graph, &context.edges, pweight)); ------------------ | | 656| 682| do { \ | | 657| 682| igraph_error_t igraph_i_ret = (expr); \ | | 658| 682| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 682| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 186, False: 496] | | | | ------------------ | | ------------------ | | 659| 186| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 186| do { \ | | | | 427| 186| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 186| return igraph_errno ; \ | | | | 429| 186| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 186| } \ | | 661| 682| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 496] | | ------------------ ------------------ 185| | 186| 496| if (pweight) { ------------------ | Branch (186:9): [True: 144, False: 352] ------------------ 187| 144| igraph_attribute_record_list_destroy(pweight); 188| 144| IGRAPH_FINALLY_CLEAN(1); 189| 144| } 190| | 191| 496| if (pname) { ------------------ | Branch (191:9): [True: 36, False: 460] ------------------ 192| 36| igraph_attribute_record_list_destroy(pname); 193| 36| IGRAPH_FINALLY_CLEAN(1); 194| 36| } 195| | 196| | /* don't destroy the graph itself but pop it from the finally stack */ 197| 496| IGRAPH_FINALLY_CLEAN(1); 198| | 199| 496| igraph_trie_destroy(&context.trie); 200| 496| igraph_strvector_destroy(&context.labels); 201| 496| igraph_vector_int_destroy(&context.edges); 202| 496| igraph_vector_destroy(&context.weights); 203| 496| igraph_dl_yylex_destroy(context.scanner); 204| 496| IGRAPH_FINALLY_CLEAN(5); 205| | 206| 496| return IGRAPH_SUCCESS; 207| 682|} igraph_i_parse_integer: 52| 6.21M|igraph_error_t igraph_i_parse_integer(const char *str, size_t length, igraph_int_t *value) { 53| 6.21M| char buffer[128]; 54| 6.21M| char *tmp, *end; 55| 6.21M| char last_char; 56| 6.21M| igraph_bool_t out_of_range, dynamic_alloc; 57| 6.21M| long long val; 58| | 59| 6.21M| if (length == 0) { ------------------ | Branch (59:9): [True: 0, False: 6.21M] ------------------ 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.21M| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 64| | 65| 6.21M| if (dynamic_alloc) { ------------------ | Branch (65:9): [True: 216, False: 6.21M] ------------------ 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.21M| } else { 69| 6.21M| tmp = buffer; 70| 6.21M| } 71| | 72| 6.21M| strncpy(tmp, str, length); 73| 6.21M| 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.21M| errno = 0; 79| 6.21M| val = strtoll(tmp, &end, 10); 80| 6.21M| out_of_range = errno == ERANGE; 81| 6.21M| *value = (igraph_int_t) val; 82| 6.21M| last_char = *end; 83| 6.21M| if (*value != val) { ------------------ | Branch (83:9): [True: 0, False: 6.21M] ------------------ 84| 0| out_of_range = true; 85| 0| } 86| | 87| | /* Free memory before raising any errors. */ 88| 6.21M| if (dynamic_alloc) { ------------------ | Branch (88:9): [True: 216, False: 6.21M] ------------------ 89| 216| IGRAPH_FREE(tmp); ------------------ | | 36| 216|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 90| 216| } 91| | 92| 6.21M| if (out_of_range) { ------------------ | Branch (92:9): [True: 38, False: 6.21M] ------------------ 93| 38| IGRAPH_ERROR("Failed to parse integer.", val > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 426| 38| do { \ | | 427| 76| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (427:63): [True: 36, False: 2] | | ------------------ | | 428| 76| return igraph_errno ; \ | | ------------------ | | | Branch (428:16): [True: 36, False: 2] | | ------------------ | | 429| 38| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 94| 38| } 95| | 96| | /* Did we parse to the end of the string? */ 97| 6.21M| if (last_char) { ------------------ | Branch (97:9): [True: 2, False: 6.21M] ------------------ 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.21M| return IGRAPH_SUCCESS; 102| 6.21M|} igraph_i_parse_real: 113| 38.9k|igraph_error_t igraph_i_parse_real(const char *str, size_t length, igraph_real_t *value) { 114| 38.9k| char buffer[128]; 115| 38.9k| char *tmp, *end; 116| 38.9k| char last_char; 117| 38.9k| igraph_bool_t out_of_range, dynamic_alloc; 118| | 119| 38.9k| if (length == 0) { ------------------ | Branch (119:9): [True: 0, False: 38.9k] ------------------ 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| 38.9k| dynamic_alloc = length+1 > sizeof(buffer) / sizeof(buffer[0]); 124| | 125| 38.9k| if (dynamic_alloc) { ------------------ | Branch (125:9): [True: 216, False: 38.7k] ------------------ 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| 38.7k| } else { 129| 38.7k| tmp = buffer; 130| 38.7k| } 131| | 132| 38.9k| strncpy(tmp, str, length); 133| 38.9k| tmp[length]='\0'; 134| | 135| 38.9k| errno = 0; 136| 38.9k| *value = strtod(tmp, &end); 137| 38.9k| out_of_range = errno == ERANGE; /* This does not trigger when reading +-Inf. */ 138| 38.9k| last_char = *end; 139| | 140| | /* Free memory before raising any errors. */ 141| 38.9k| if (dynamic_alloc) { ------------------ | Branch (141:9): [True: 216, False: 38.7k] ------------------ 142| 216| IGRAPH_FREE(tmp); ------------------ | | 36| 216|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 143| 216| } 144| | 145| 38.9k| if (out_of_range) { ------------------ | Branch (145:9): [True: 23, False: 38.9k] ------------------ 146| 23| IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 426| 23| do { \ | | 427| 46| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (427:63): [True: 13, False: 10] | | ------------------ | | 428| 46| return igraph_errno ; \ | | ------------------ | | | Branch (428:16): [True: 13, False: 10] | | ------------------ | | 429| 23| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 147| 23| } 148| | 149| | /* Did we parse to the end of the string? */ 150| 38.9k| if (last_char) { ------------------ | Branch (150:9): [True: 0, False: 38.9k] ------------------ 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| 38.9k| return IGRAPH_SUCCESS; 155| 38.9k|}