igraph_dl_yylex: 1151| 10.5M|{ 1152| 10.5M| yy_state_type yy_current_state; 1153| 10.5M| char *yy_cp, *yy_bp; 1154| 10.5M| int yy_act; 1155| 10.5M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1156| | 1157| 10.5M| yylval = yylval_param; ------------------ | | 964| 10.5M| # define yylval yyg->yylval_r ------------------ 1158| | 1159| 10.5M| yylloc = yylloc_param; ------------------ | | 966| 10.5M| # define yylloc yyg->yylloc_r ------------------ 1160| | 1161| 10.5M| if ( !yyg->yy_init ) ------------------ | Branch (1161:7): [True: 2.31k, False: 10.5M] ------------------ 1162| 2.31k| { 1163| 2.31k| yyg->yy_init = 1; 1164| | 1165| |#ifdef YY_USER_INIT 1166| | YY_USER_INIT; 1167| |#endif 1168| | 1169| 2.31k| if ( ! yyg->yy_start ) ------------------ | Branch (1169:8): [True: 2.31k, False: 0] ------------------ 1170| 2.31k| yyg->yy_start = 1; /* first start state */ 1171| | 1172| 2.31k| if ( ! yyin ) ------------------ | | 356| 2.31k|#define yyin yyg->yyin_r ------------------ | Branch (1172:8): [True: 0, False: 2.31k] ------------------ 1173| 0| yyin = stdin; ------------------ | | 356| 0|#define yyin yyg->yyin_r ------------------ 1174| | 1175| 2.31k| if ( ! yyout ) ------------------ | | 357| 2.31k|#define yyout yyg->yyout_r ------------------ | Branch (1175:8): [True: 2.31k, False: 0] ------------------ 1176| 2.31k| yyout = stdout; ------------------ | | 357| 2.31k|#define yyout yyg->yyout_r ------------------ 1177| | 1178| 2.31k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 521| 2.31k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 0, False: 2.31k] | | ------------------ | | 522| 2.31k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.31k| : NULL) ------------------ | Branch (1178:8): [True: 2.31k, False: 0] ------------------ 1179| 2.31k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 2.31k|#define yyensure_buffer_stack igraph_dl_yyensure_buffer_stack ------------------ 1180| 2.31k| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 527| 2.31k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1181| 2.31k| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 2.31k|#define yy_create_buffer igraph_dl_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 356| 2.31k|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 391| 2.31k|#define YY_BUF_SIZE 16384 ------------------ 1182| 2.31k| } 1183| | 1184| 2.31k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.31k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1185| 2.31k| } 1186| | 1187| 10.5M| { 1188| 10.5M|#line 80 "/src/igraph/src/io/dl-lexer.l" 1189| | 1190| | 1191| 10.5M|#line 1192 "/src/igraph/build/src/io/parsers/dl-lexer.c" 1192| | 1193| 17.3M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1193:23): [True: 17.3M, Folded] ------------------ 1194| 17.3M| { 1195| 17.3M| yy_cp = yyg->yy_c_buf_p; 1196| | 1197| | /* Support of yytext. */ 1198| 17.3M| *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.3M| yy_bp = yy_cp; 1204| | 1205| 17.3M| yy_current_state = yyg->yy_start; 1206| 17.3M|yy_match: 1207| 17.3M| do 1208| 51.9M| { 1209| 51.9M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 346| 51.9M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1210| 51.9M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1210:9): [True: 46.7M, False: 5.19M] ------------------ 1211| 46.7M| { 1212| 46.7M| yyg->yy_last_accepting_state = yy_current_state; 1213| 46.7M| yyg->yy_last_accepting_cpos = yy_cp; 1214| 46.7M| } 1215| 85.1M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1215:12): [True: 33.2M, False: 51.9M] ------------------ 1216| 33.2M| { 1217| 33.2M| yy_current_state = (int) yy_def[yy_current_state]; 1218| 33.2M| if ( yy_current_state >= 129 ) ------------------ | Branch (1218:10): [True: 18.5M, False: 14.7M] ------------------ 1219| 18.5M| yy_c = yy_meta[yy_c]; 1220| 33.2M| } 1221| 51.9M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1222| 51.9M| ++yy_cp; 1223| 51.9M| } 1224| 51.9M| while ( yy_base[yy_current_state] != 493 ); ------------------ | Branch (1224:11): [True: 34.6M, False: 17.3M] ------------------ 1225| | 1226| 17.3M|yy_find_action: 1227| 17.3M| yy_act = yy_accept[yy_current_state]; 1228| 17.3M| if ( yy_act == 0 ) ------------------ | Branch (1228:8): [True: 14.4M, False: 2.91M] ------------------ 1229| 14.4M| { /* have to back up */ 1230| 14.4M| yy_cp = yyg->yy_last_accepting_cpos; 1231| 14.4M| yy_current_state = yyg->yy_last_accepting_state; 1232| 14.4M| yy_act = yy_accept[yy_current_state]; 1233| 14.4M| } 1234| | 1235| 17.3M| YY_DO_BEFORE_ACTION; ------------------ | | 588| 17.3M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 577| 17.3M|#define yytext_ptr yytext_r | | ------------------ | | 589| 17.3M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 359| 17.3M|#define yyleng yyg->yyleng_r | | ------------------ | | 590| 17.3M| yyg->yy_hold_char = *yy_cp; \ | | 591| 17.3M| *yy_cp = '\0'; \ | | 592| 17.3M| yyg->yy_c_buf_p = yy_cp; ------------------ 1236| | 1237| 17.3M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 594| 34.7M|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1237:8): [True: 17.3M, False: 11.6k] | Branch (1237:38): [True: 2.56M, False: 14.7M] ------------------ 1238| 2.56M| { 1239| 2.56M| int yyl; 1240| 5.12M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 359| 5.12M|#define yyleng yyg->yyleng_r ------------------ | Branch (1240:19): [True: 2.56M, False: 2.56M] ------------------ 1241| 2.56M| if ( yytext[yyl] == '\n' ) ------------------ | | 360| 2.56M|#define yytext yyg->yytext_r ------------------ | Branch (1241:10): [True: 2.56M, False: 1.45k] ------------------ 1242| | 1243| 2.56M| do{ yylineno++; ------------------ | | 361| 2.56M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 527| 2.56M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1244| 2.56M| yycolumn=0; ------------------ | | 362| 2.56M|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 527| 2.56M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1245| 2.56M| }while(0) ------------------ | Branch (1245:12): [Folded, False: 2.56M] ------------------ 1246| 2.56M|; 1247| 2.56M| } 1248| | 1249| 17.3M|do_action: /* This label is used only to access EOF actions. */ 1250| | 1251| 17.3M| switch ( yy_act ) 1252| 17.3M| { /* beginning of action switch */ 1253| 0| case 0: /* must back up */ ------------------ | Branch (1253:4): [True: 0, False: 17.3M] ------------------ 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.56M|case 1: ------------------ | Branch (1260:1): [True: 2.56M, False: 14.7M] ------------------ 1261| |/* rule 1 can match eol */ 1262| 2.56M|YY_RULE_SETUP ------------------ | | 1146| 2.56M| YY_USER_ACTION | | ------------------ | | | | 890| 2.56M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.56M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.56M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.56M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1263| 2.56M|#line 82 "/src/igraph/src/io/dl-lexer.l" 1264| 2.56M|{ return NEWLINE; } 1265| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1266| 2.15k|case 2: ------------------ | Branch (1266:1): [True: 2.15k, False: 17.3M] ------------------ 1267| 2.15k|YY_RULE_SETUP ------------------ | | 1146| 2.15k| YY_USER_ACTION | | ------------------ | | | | 890| 2.15k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.15k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.15k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1268| 2.15k|#line 84 "/src/igraph/src/io/dl-lexer.l" 1269| 2.15k|{ return DL; } 1270| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1271| 2.14k|case 3: ------------------ | Branch (1271:1): [True: 2.14k, False: 17.3M] ------------------ 1272| 2.14k|YY_RULE_SETUP ------------------ | | 1146| 2.14k| YY_USER_ACTION | | ------------------ | | | | 890| 2.14k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.14k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.14k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.14k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1273| 2.14k|#line 85 "/src/igraph/src/io/dl-lexer.l" 1274| 2.14k|{ return NEQ; } 1275| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1276| 2.15k|case 4: ------------------ | Branch (1276:1): [True: 2.15k, False: 17.3M] ------------------ 1277| 2.15k|YY_RULE_SETUP ------------------ | | 1146| 2.15k| YY_USER_ACTION | | ------------------ | | | | 890| 2.15k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 2.15k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 2.15k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 2.15k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1278| 2.15k|#line 86 "/src/igraph/src/io/dl-lexer.l" 1279| 2.15k|{ return NUM; } 1280| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1281| 1.98k|case 5: ------------------ | Branch (1281:1): [True: 1.98k, False: 17.3M] ------------------ 1282| 1.98k|YY_RULE_SETUP ------------------ | | 1146| 1.98k| YY_USER_ACTION | | ------------------ | | | | 890| 1.98k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.98k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.98k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.98k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1283| 1.98k|#line 88 "/src/igraph/src/io/dl-lexer.l" 1284| 1.98k|{ 1285| 1.98k| switch (yyextra->mode) { ------------------ | | 358| 1.98k|#define yyextra yyg->yyextra_r ------------------ | Branch (1285:11): [True: 1.98k, False: 0] ------------------ 1286| 483| case 0: BEGIN(FULLMATRIX); ------------------ | | 369| 483|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 0: BEGIN(FULLMATRIX); ------------------ | | 906| 483|#define FULLMATRIX 2 ------------------ | Branch (1286:3): [True: 483, False: 1.49k] ------------------ 1287| 483| break; 1288| 986| case 1: BEGIN(EDGELIST); ------------------ | | 369| 986|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 1: BEGIN(EDGELIST); ------------------ | | 907| 986|#define EDGELIST 3 ------------------ | Branch (1288:3): [True: 986, False: 996] ------------------ 1289| 986| break; 1290| 513| case 2: BEGIN(NODELIST); ------------------ | | 369| 513|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ case 2: BEGIN(NODELIST); ------------------ | | 908| 513|#define NODELIST 4 ------------------ | Branch (1290:3): [True: 513, False: 1.46k] ------------------ 1291| 513| break; 1292| 1.98k| } 1293| 1.98k| return DATA; } 1294| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1295| 333|case 6: ------------------ | Branch (1295:1): [True: 333, False: 17.3M] ------------------ 1296| 333|YY_RULE_SETUP ------------------ | | 1146| 333| YY_USER_ACTION | | ------------------ | | | | 890| 333|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 333| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 333|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 333|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1297| 333|#line 99 "/src/igraph/src/io/dl-lexer.l" 1298| 333|{ BEGIN(LABELM); return LABELS; } ------------------ | | 369| 333|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(LABELM); return LABELS; } ------------------ | | 905| 333|#define LABELM 1 ------------------ 1299| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1300| 378|case 7: ------------------ | Branch (1300:1): [True: 378, False: 17.3M] ------------------ 1301| 378|YY_RULE_SETUP ------------------ | | 1146| 378| YY_USER_ACTION | | ------------------ | | | | 890| 378|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 378| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 378|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 378|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1302| 378|#line 100 "/src/igraph/src/io/dl-lexer.l" 1303| 378|{ 1304| 378| return LABELSEMBEDDED; } 1305| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1306| 4|case 8: ------------------ | Branch (1306:1): [True: 4, False: 17.3M] ------------------ 1307| 4|YY_RULE_SETUP ------------------ | | 1146| 4| YY_USER_ACTION | | ------------------ | | | | 890| 4|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 4| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 4|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 4|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1308| 4|#line 102 "/src/igraph/src/io/dl-lexer.l" 1309| 4|{ 1310| 4| yyextra->mode=0; return FORMATFULLMATRIX; } ------------------ | | 358| 4|#define yyextra yyg->yyextra_r ------------------ 1311| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1312| 1.01k|case 9: ------------------ | Branch (1312:1): [True: 1.01k, False: 17.3M] ------------------ 1313| 1.01k|YY_RULE_SETUP ------------------ | | 1146| 1.01k| YY_USER_ACTION | | ------------------ | | | | 890| 1.01k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.01k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.01k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.01k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1314| 1.01k|#line 104 "/src/igraph/src/io/dl-lexer.l" 1315| 1.01k|{ 1316| 1.01k| yyextra->mode=1; return FORMATEDGELIST1; } ------------------ | | 358| 1.01k|#define yyextra yyg->yyextra_r ------------------ 1317| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1318| 527|case 10: ------------------ | Branch (1318:1): [True: 527, False: 17.3M] ------------------ 1319| 527|YY_RULE_SETUP ------------------ | | 1146| 527| YY_USER_ACTION | | ------------------ | | | | 890| 527|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 527| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 527|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 527|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1320| 527|#line 106 "/src/igraph/src/io/dl-lexer.l" 1321| 527|{ 1322| 527| yyextra->mode=2; return FORMATNODELIST1; } ------------------ | | 358| 527|#define yyextra yyg->yyextra_r ------------------ 1323| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1324| 6.97k|case 11: ------------------ | Branch (1324:1): [True: 6.97k, False: 17.3M] ------------------ 1325| 6.97k|YY_RULE_SETUP ------------------ | | 1146| 6.97k| YY_USER_ACTION | | ------------------ | | | | 890| 6.97k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 6.97k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 6.97k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 6.97k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1326| 6.97k|#line 109 "/src/igraph/src/io/dl-lexer.l" 1327| 6.97k|{ /* eaten up */ } 1328| 6.97k| YY_BREAK ------------------ | | 1142| 6.97k|#define YY_BREAK /*LINTED*/break; ------------------ 1329| 1.61M|case 12: ------------------ | Branch (1329:1): [True: 1.61M, False: 15.7M] ------------------ 1330| 1.61M|YY_RULE_SETUP ------------------ | | 1146| 1.61M| YY_USER_ACTION | | ------------------ | | | | 890| 1.61M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.61M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.61M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.61M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1331| 1.61M|#line 110 "/src/igraph/src/io/dl-lexer.l" 1332| 1.61M|{ return LABEL; } 1333| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1334| 58.4k|case 13: ------------------ | Branch (1334:1): [True: 58.4k, False: 17.2M] ------------------ 1335| 58.4k|YY_RULE_SETUP ------------------ | | 1146| 58.4k| YY_USER_ACTION | | ------------------ | | | | 890| 58.4k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 58.4k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 58.4k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 58.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1336| 58.4k|#line 112 "/src/igraph/src/io/dl-lexer.l" 1337| 58.4k|{ 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.3M] ------------------ 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.4M] ------------------ 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.73M|case 16: ------------------ | Branch (1349:1): [True: 4.73M, False: 12.6M] ------------------ 1350| 4.73M|YY_RULE_SETUP ------------------ | | 1146| 4.73M| YY_USER_ACTION | | ------------------ | | | | 890| 4.73M|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 4.73M| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 4.73M|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 4.73M|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1351| 4.73M|#line 116 "/src/igraph/src/io/dl-lexer.l" 1352| 4.73M|{ return NUM; } 1353| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1354| 1.38k|case 17: ------------------ | Branch (1354:1): [True: 1.38k, False: 17.3M] ------------------ 1355| 1.38k|YY_RULE_SETUP ------------------ | | 1146| 1.38k| YY_USER_ACTION | | ------------------ | | | | 890| 1.38k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 1.38k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 1.38k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 1.38k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1356| 1.38k|#line 117 "/src/igraph/src/io/dl-lexer.l" 1357| 1.38k|{ 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: 14.9M] ------------------ 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.8M] ------------------ 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.49k|case 20: ------------------ | Branch (1369:1): [True: 7.49k, False: 17.3M] ------------------ 1370| 7.49k|YY_RULE_SETUP ------------------ | | 1146| 7.49k| YY_USER_ACTION | | ------------------ | | | | 890| 7.49k|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 7.49k| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 7.49k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 7.49k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1371| 7.49k|#line 121 "/src/igraph/src/io/dl-lexer.l" 1372| 7.49k|{ 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.8M] ------------------ 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| 64|case 22: ------------------ | Branch (1379:1): [True: 64, False: 17.3M] ------------------ 1380| 64|YY_RULE_SETUP ------------------ | | 1146| 64| YY_USER_ACTION | | ------------------ | | | | 890| 64|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 64| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 64|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 64|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1381| 64|#line 124 "/src/igraph/src/io/dl-lexer.l" 1382| 64|{ /* eaten up */ } 1383| 64| YY_BREAK ------------------ | | 1142| 64|#define YY_BREAK /*LINTED*/break; ------------------ 1384| 834|case YY_STATE_EOF(INITIAL): ------------------ | | 377| 834|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 834|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1384:1): [True: 834, False: 17.3M] ------------------ 1385| 902|case YY_STATE_EOF(LABELM): ------------------ | | 377| 902|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 902|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1385:1): [True: 68, False: 17.3M] ------------------ 1386| 1.33k|case YY_STATE_EOF(FULLMATRIX): ------------------ | | 377| 1.33k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.33k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1386:1): [True: 431, False: 17.3M] ------------------ 1387| 1.81k|case YY_STATE_EOF(EDGELIST): ------------------ | | 377| 1.81k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 1.81k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1387:1): [True: 477, False: 17.3M] ------------------ 1388| 2.20k|case YY_STATE_EOF(NODELIST): ------------------ | | 377| 2.20k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.20k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ | Branch (1388:1): [True: 391, False: 17.3M] ------------------ 1389| 2.20k|#line 126 "/src/igraph/src/io/dl-lexer.l" 1390| 2.20k|{ 1391| 2.20k| if (yyextra->eof) { ------------------ | | 358| 2.20k|#define yyextra yyg->yyextra_r ------------------ | Branch (1391:31): [True: 794, False: 1.40k] ------------------ 1392| 794| yyterminate(); ------------------ | | 1105| 794|#define yyterminate() return YY_NULL | | ------------------ | | | | 341| 794|#define YY_NULL 0 | | ------------------ ------------------ 1393| 1.40k| } else { 1394| 1.40k| yyextra->eof=1; ------------------ | | 358| 1.40k|#define yyextra yyg->yyextra_r ------------------ 1395| 1.40k| BEGIN(INITIAL); ------------------ | | 369| 1.40k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 904| 1.40k|#define INITIAL 0 ------------------ 1396| 1.40k| return EOFF; 1397| 1.40k| } 1398| 2.20k| } 1399| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1400| 153|case 23: ------------------ | Branch (1400:1): [True: 153, False: 17.3M] ------------------ 1401| 153|YY_RULE_SETUP ------------------ | | 1146| 153| YY_USER_ACTION | | ------------------ | | | | 890| 153|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 153| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 153|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 153|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1402| 153|#line 136 "/src/igraph/src/io/dl-lexer.l" 1403| 153|{ return 0; } 1404| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1405| 0|case 24: ------------------ | Branch (1405:1): [True: 0, False: 17.3M] ------------------ 1406| 0|YY_RULE_SETUP ------------------ | | 1146| 0| YY_USER_ACTION | | ------------------ | | | | 890| 0|#define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 966| 0| # define yylloc yyg->yylloc_r | | | | ------------------ | | | | #define YY_USER_ACTION yylloc->first_line = yylineno; | | | | ------------------ | | | | | | 361| 0|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | | | | | ------------------ | | | | | | | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1407| 0|#line 137 "/src/igraph/src/io/dl-lexer.l" 1408| 0|YY_FATAL_ERROR( "flex scanner jammed" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1409| 0| YY_BREAK ------------------ | | 1142| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1410| 0|#line 1411 "/src/igraph/build/src/io/parsers/dl-lexer.c" 1411| | 1412| 11.6k| case YY_END_OF_BUFFER: ------------------ | | 594| 11.6k|#define YY_END_OF_BUFFER 25 ------------------ | Branch (1412:2): [True: 11.6k, False: 17.3M] ------------------ 1413| 11.6k| { 1414| | /* Amount of text matched not including the EOB char. */ 1415| 11.6k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 577| 11.6k|#define yytext_ptr yytext_r ------------------ 1416| | 1417| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1418| 11.6k| *yy_cp = yyg->yy_hold_char; 1419| 11.6k| YY_RESTORE_YY_MORE_OFFSET 1420| | 1421| 11.6k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 527| 11.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 498| 11.6k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1421:8): [True: 3.10k, False: 8.56k] ------------------ 1422| 3.10k| { 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.10k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 3.10k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1433| 3.10k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 527| 3.10k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 356| 3.10k|#define yyin yyg->yyin_r ------------------ 1434| 3.10k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 527| 3.10k|#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.10k|#define YY_BUFFER_NORMAL 1 ------------------ 1435| 3.10k| } 1436| | 1437| | /* Note that here we test for yy_c_buf_p "<=" to the position 1438| | * of the first EOB in the buffer, since yy_c_buf_p will 1439| | * already have been incremented past the NUL character 1440| | * (since all states make transitions on EOB to the 1441| | * end-of-buffer state). Contrast this with the test 1442| | * in input(). 1443| | */ 1444| 11.6k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 527| 11.6k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1444:8): [True: 195, False: 11.4k] ------------------ 1445| 195| { /* This was really a NUL. */ 1446| 195| yy_state_type yy_next_state; 1447| | 1448| 195| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 195|#define yytext_ptr yytext_r ------------------ 1449| | 1450| 195| 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| 195| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1462| | 1463| 195| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 195|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 195|#define YY_MORE_ADJ 0 ------------------ 1464| | 1465| 195| if ( yy_next_state ) ------------------ | Branch (1465:9): [True: 66, False: 129] ------------------ 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| 129| else 1474| 129| { 1475| 129| yy_cp = yyg->yy_c_buf_p; 1476| 129| goto yy_find_action; 1477| 129| } 1478| 195| } 1479| | 1480| 11.4k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1480:17): [True: 11.4k, False: 0] ------------------ 1481| 11.4k| { 1482| 2.20k| case EOB_ACT_END_OF_FILE: ------------------ | | 410| 2.20k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1482:4): [True: 2.20k, False: 9.27k] ------------------ 1483| 2.20k| { 1484| 2.20k| yyg->yy_did_buffer_switch_on_eof = 0; 1485| | 1486| 2.20k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 2.20k|#define yywrap igraph_dl_yywrap | | ------------------ | | | | 571| 2.20k|#define igraph_dl_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (571:37): [True: 2.20k, Folded] | | | | ------------------ | | ------------------ ------------------ 1487| 2.20k| { 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.20k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.20k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.20k|#define YY_MORE_ADJ 0 ------------------ 1498| | 1499| 2.20k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 377| 2.20k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 594| 2.20k|#define YY_END_OF_BUFFER 25 | | ------------------ ------------------ 1500| 2.20k| goto do_action; 1501| 2.20k| } 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.20k| } 1510| | 1511| 7.21k| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 409| 7.21k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1511:4): [True: 7.21k, False: 4.25k] ------------------ 1512| 7.21k| yyg->yy_c_buf_p = 1513| 7.21k| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 577| 7.21k|#define yytext_ptr yytext_r ------------------ 1514| | 1515| 7.21k| yy_current_state = yy_get_previous_state( yyscanner ); 1516| | 1517| 7.21k| yy_cp = yyg->yy_c_buf_p; 1518| 7.21k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 7.21k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 7.21k|#define YY_MORE_ADJ 0 ------------------ 1519| 7.21k| goto yy_match; 1520| | 1521| 2.05k| case EOB_ACT_LAST_MATCH: ------------------ | | 411| 2.05k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1521:4): [True: 2.05k, False: 9.41k] ------------------ 1522| 2.05k| yyg->yy_c_buf_p = 1523| 2.05k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 527| 2.05k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1524| | 1525| 2.05k| yy_current_state = yy_get_previous_state( yyscanner ); 1526| | 1527| 2.05k| yy_cp = yyg->yy_c_buf_p; 1528| 2.05k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 577| 2.05k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 836| 2.05k|#define YY_MORE_ADJ 0 ------------------ 1529| 2.05k| goto yy_find_action; 1530| 11.4k| } 1531| 0| break; 1532| 11.6k| } 1533| | 1534| 0| default: ------------------ | Branch (1534:2): [True: 0, False: 17.3M] ------------------ 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.3M| "fatal flex scanner internal error--no action found" ); 1537| 17.3M| } /* end of action switch */ 1538| 17.3M| } /* end of scanning one token */ 1539| 10.5M| } /* end of user's declarations */ 1540| 10.5M|} /* end of yylex */ igraph_dl_yyrestart: 1838| 2.20k|{ 1839| 2.20k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1840| | 1841| 2.20k| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 521| 2.20k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.20k, False: 0] | | ------------------ | | 522| 2.20k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.20k| : NULL) ------------------ | Branch (1841:7): [True: 0, False: 2.20k] ------------------ 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.20k| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 50| 2.20k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 521| 2.20k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.20k, False: 0] | | ------------------ | | 522| 2.20k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.20k| : NULL) ------------------ 1848| 2.20k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.20k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 1849| 2.20k|} igraph_dl_yy_create_buffer: 1903| 2.31k|{ 1904| 2.31k| YY_BUFFER_STATE b; 1905| | 1906| 2.31k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 236| 2.31k|#define yyalloc igraph_dl_yyalloc ------------------ 1907| 2.31k| if ( ! b ) ------------------ | Branch (1907:7): [True: 0, False: 2.31k] ------------------ 1908| 2.31k| 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.31k| 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.31k| b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); ------------------ | | 236| 2.31k|#define yyalloc igraph_dl_yyalloc ------------------ 1916| 2.31k| if ( ! b->yy_ch_buf ) ------------------ | Branch (1916:7): [True: 0, False: 2.31k] ------------------ 1917| 2.31k| 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.31k| b->yy_is_our_buffer = 1; 1920| | 1921| 2.31k| yy_init_buffer( b, file , yyscanner); ------------------ | | 50| 2.31k|#define yy_init_buffer igraph_dl_yy_init_buffer ------------------ 1922| | 1923| 2.31k| return b; 1924| 2.31k|} igraph_dl_yy_delete_buffer: 1931| 2.31k|{ 1932| 2.31k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1933| | 1934| 2.31k| if ( ! b ) ------------------ | Branch (1934:7): [True: 0, False: 2.31k] ------------------ 1935| 0| return; 1936| | 1937| 2.31k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 521| 2.31k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.31k, False: 0] | | ------------------ | | 522| 2.31k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.31k| : NULL) ------------------ | Branch (1937:7): [True: 2.31k, False: 0] ------------------ 1938| 2.31k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 527| 2.31k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1939| | 1940| 2.31k| if ( b->yy_is_our_buffer ) ------------------ | Branch (1940:7): [True: 2.31k, False: 0] ------------------ 1941| 2.31k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 248| 2.31k|#define yyfree igraph_dl_yyfree ------------------ 1942| | 1943| 2.31k| yyfree( (void *) b , yyscanner ); ------------------ | | 248| 2.31k|#define yyfree igraph_dl_yyfree ------------------ 1944| 2.31k|} igraph_dl_yy_flush_buffer: 1980| 4.51k|{ 1981| 4.51k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1982| 4.51k| if ( ! b ) ------------------ | Branch (1982:7): [True: 0, False: 4.51k] ------------------ 1983| 0| return; 1984| | 1985| 4.51k| 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.51k| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.51k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1992| 4.51k| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 4.51k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1993| | 1994| 4.51k| b->yy_buf_pos = &b->yy_ch_buf[0]; 1995| | 1996| 4.51k| b->yy_at_bol = 1; 1997| 4.51k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 498| 4.51k|#define YY_BUFFER_NEW 0 ------------------ 1998| | 1999| 4.51k| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 521| 4.51k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.51k, False: 0] | | ------------------ | | 522| 4.51k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.51k| : NULL) ------------------ | Branch (1999:7): [True: 2.20k, False: 2.31k] ------------------ 2000| 2.20k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 2.20k|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2001| 4.51k|} igraph_dl_yypop_buffer_state: 2041| 2.31k|{ 2042| 2.31k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2043| 2.31k| if (!YY_CURRENT_BUFFER) ------------------ | | 521| 2.31k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.31k, False: 0] | | ------------------ | | 522| 2.31k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.31k| : NULL) ------------------ | Branch (2043:6): [True: 2.31k, False: 0] ------------------ 2044| 2.31k| return; 2045| | 2046| 0| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 26| 0|#define yy_delete_buffer igraph_dl_yy_delete_buffer ------------------ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 521| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 0, False: 0] | | ------------------ | | 522| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 0| : NULL) ------------------ 2047| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2048| 0| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2048:6): [True: 0, False: 0] ------------------ 2049| 0| --yyg->yy_buffer_stack_top; 2050| | 2051| 0| if (YY_CURRENT_BUFFER) { ------------------ | | 521| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:27): [True: 0, False: 0] | | | Branch (521:29): [True: 0, False: 0] | | ------------------ | | 522| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 0| : NULL) ------------------ 2052| 0| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 0|#define yy_load_buffer_state igraph_dl_yy_load_buffer_state ------------------ 2053| 0| yyg->yy_did_buffer_switch_on_eof = 1; 2054| 0| } 2055| 0|} igraph_dl_yyget_leng: 2278| 7.88M|{ 2279| 7.88M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2280| 7.88M| return yyleng; ------------------ | | 359| 7.88M|#define yyleng yyg->yyleng_r ------------------ 2281| 7.88M|} igraph_dl_yyget_text: 2288| 7.94M|{ 2289| 7.94M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2290| 7.94M| return yytext; ------------------ | | 360| 7.94M|#define yytext yyg->yytext_r ------------------ 2291| 7.94M|} igraph_dl_yyset_extra: 2298| 4.62k|{ 2299| 4.62k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2300| 4.62k| yyextra = user_defined ; ------------------ | | 358| 4.62k|#define yyextra yyg->yyextra_r ------------------ 2301| 4.62k|} igraph_dl_yyset_in: 2340| 2.31k|{ 2341| 2.31k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2342| 2.31k| yyin = _in_str ; ------------------ | | 356| 2.31k|#define yyin yyg->yyin_r ------------------ 2343| 2.31k|} igraph_dl_yylex_init_extra: 2423| 2.31k|{ 2424| 2.31k| struct yyguts_t dummy_yyguts; 2425| | 2426| 2.31k| yyset_extra (yy_user_defined, &dummy_yyguts); ------------------ | | 140| 2.31k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2427| | 2428| 2.31k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2428:9): [True: 0, False: 2.31k] ------------------ 2429| 0| errno = EINVAL; 2430| 0| return 1; 2431| 0| } 2432| | 2433| 2.31k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); ------------------ | | 236| 2.31k|#define yyalloc igraph_dl_yyalloc ------------------ 2434| | 2435| 2.31k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2435:9): [True: 0, False: 2.31k] ------------------ 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.31k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2443| | 2444| 2.31k| yyset_extra (yy_user_defined, *ptr_yy_globals); ------------------ | | 140| 2.31k|#define yyset_extra igraph_dl_yyset_extra ------------------ 2445| | 2446| 2.31k| return yy_init_globals ( *ptr_yy_globals ); 2447| 2.31k|} igraph_dl_yylex_destroy: 2484| 2.31k|{ 2485| 2.31k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2486| | 2487| | /* Pop the buffer stack, destroying each element. */ 2488| 4.62k| while(YY_CURRENT_BUFFER){ ------------------ | | 521| 4.62k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:27): [True: 2.31k, False: 2.31k] | | | Branch (521:29): [True: 4.62k, False: 0] | | ------------------ | | 522| 4.62k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.62k| : NULL) ------------------ 2489| 2.31k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 2.31k|#define yy_delete_buffer igraph_dl_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 521| 2.31k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 2.31k, False: 0] | | ------------------ | | 522| 2.31k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 2.31k| : NULL) ------------------ 2490| 2.31k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 527| 2.31k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2491| 2.31k| yypop_buffer_state(yyscanner); ------------------ | | 80| 2.31k|#define yypop_buffer_state igraph_dl_yypop_buffer_state ------------------ 2492| 2.31k| } 2493| | 2494| | /* Destroy the stack itself. */ 2495| 2.31k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 248| 2.31k|#define yyfree igraph_dl_yyfree ------------------ 2496| 2.31k| yyg->yy_buffer_stack = NULL; 2497| | 2498| | /* Destroy the start condition stack. */ 2499| 2.31k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 248| 2.31k|#define yyfree igraph_dl_yyfree ------------------ 2500| 2.31k| 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.31k| yy_init_globals( yyscanner); 2505| | 2506| | /* Destroy the main struct (reentrant only). */ 2507| 2.31k| yyfree ( yyscanner , yyscanner ); ------------------ | | 248| 2.31k|#define yyfree igraph_dl_yyfree ------------------ 2508| | yyscanner = NULL; 2509| 2.31k| return 0; 2510| 2.31k|} igraph_dl_yyalloc: 2540| 9.24k|{ 2541| 9.24k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2542| 9.24k| (void)yyg; 2543| 9.24k| return malloc(size); 2544| 9.24k|} igraph_dl_yyrealloc: 2547| 191|{ 2548| 191| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2549| 191| (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| 191| return realloc(ptr, size); 2559| 191|} igraph_dl_yyfree: 2562| 11.5k|{ 2563| 11.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2564| 11.5k| (void)yyg; 2565| 11.5k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2566| 11.5k|} dl-lexer.c:yy_get_next_buffer: 1550| 11.4k|{ 1551| 11.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1552| 11.4k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1553| 11.4k| char *source = yyg->yytext_ptr; ------------------ | | 577| 11.4k|#define yytext_ptr yytext_r ------------------ 1554| 11.4k| int number_to_move, i; 1555| 11.4k| int ret_val; 1556| | 1557| 11.4k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1557:7): [True: 0, False: 11.4k] ------------------ 1558| 11.4k| YY_FATAL_ERROR( ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1559| 11.4k| "fatal flex scanner internal error--end of buffer missed" ); 1560| | 1561| 11.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1561:7): [True: 0, False: 11.4k] ------------------ 1562| 0| { /* Don't try to fill the buffer, so this is an EOF. */ 1563| 0| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 577| 0|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 836| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1563:8): [True: 0, False: 0] ------------------ 1564| 0| { 1565| | /* We matched a single character, the EOB, so 1566| | * treat this as a final EOF. 1567| | */ 1568| 0| return EOB_ACT_END_OF_FILE; ------------------ | | 410| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1569| 0| } 1570| | 1571| 0| else 1572| 0| { 1573| | /* We matched some text prior to the EOB, first 1574| | * process it. 1575| | */ 1576| 0| return EOB_ACT_LAST_MATCH; ------------------ | | 411| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1577| 0| } 1578| 0| } 1579| | 1580| | /* Try to read more data. */ 1581| | 1582| | /* First move last chars to start of buffer. */ 1583| 11.4k| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 577| 11.4k|#define yytext_ptr yytext_r ------------------ 1584| | 1585| 261M| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1585:15): [True: 261M, False: 11.4k] ------------------ 1586| 261M| *(dest++) = *(source++); 1587| | 1588| 11.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 510| 11.4k|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1588:7): [True: 1.26k, False: 10.2k] ------------------ 1589| | /* don't do the read, it's not guaranteed to return an EOF, 1590| | * just force an EOF 1591| | */ 1592| 1.26k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 527| 1.26k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1593| | 1594| 10.2k| else 1595| 10.2k| { 1596| 10.2k| int num_to_read = 1597| 10.2k| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1598| | 1599| 10.4k| while ( num_to_read <= 0 ) ------------------ | Branch (1599:11): [True: 191, False: 10.2k] ------------------ 1600| 191| { /* Not enough room in the buffer - grow it. */ 1601| | 1602| | /* just a shorter name for the current buffer */ 1603| 191| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 527| 191|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1604| | 1605| 191| int yy_c_buf_p_offset = 1606| 191| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1607| | 1608| 191| if ( b->yy_is_our_buffer ) ------------------ | Branch (1608:9): [True: 191, False: 0] ------------------ 1609| 191| { 1610| 191| int new_size = b->yy_buf_size * 2; 1611| | 1612| 191| if ( new_size <= 0 ) ------------------ | Branch (1612:10): [True: 0, False: 191] ------------------ 1613| 0| b->yy_buf_size += b->yy_buf_size / 8; 1614| 191| else 1615| 191| b->yy_buf_size *= 2; 1616| | 1617| 191| b->yy_ch_buf = (char *) 1618| | /* Include room in for 2 EOB chars. */ 1619| 191| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 242| 191|#define yyrealloc igraph_dl_yyrealloc ------------------ 1620| 191| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1621| 191| } 1622| 0| else 1623| | /* Can't grow it, we don't own it. */ 1624| 0| b->yy_ch_buf = NULL; 1625| | 1626| 191| if ( ! b->yy_ch_buf ) ------------------ | Branch (1626:9): [True: 0, False: 191] ------------------ 1627| 191| 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| 191| "fatal error - scanner input buffer overflow" ); 1629| | 1630| 191| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1631| | 1632| 191| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 527| 191|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1633| 191| number_to_move - 1; 1634| | 1635| 191| } 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.52k, False: 682] ------------------ 1638| 9.52k| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1052| 9.52k|#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| 2.99k|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1085:11): [True: 2.99k, False: 7.21k] | | | Branch (1085:78): [True: 0, False: 2.99k] | | ------------------ | | 1086| 10.2k| { \ | | 1087| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1087:8): [True: 0, False: 0] | | ------------------ | | 1088| 0| { \ | | 1089| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | | | ------------------ | | | | | | 895| 0| do { \ | | | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | | | 897| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (897:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1090| 0| break; \ | | 1091| 0| } \ | | 1092| 0| errno=0; \ | | 1093| 0| clearerr(yyin); \ | | ------------------ | | | | 356| 0|#define yyin yyg->yyin_r | | ------------------ | | 1094| 0| } \ | | 1095| 10.2k| }\ ------------------ 1642| 10.2k| yyg->yy_n_chars, num_to_read ); 1643| | 1644| 10.2k| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 527| 10.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1645| 10.2k| } 1646| | 1647| 11.4k| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1647:7): [True: 4.25k, False: 7.21k] ------------------ 1648| 4.25k| { 1649| 4.25k| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 836| 4.25k|#define YY_MORE_ADJ 0 ------------------ | Branch (1649:8): [True: 2.20k, False: 2.05k] ------------------ 1650| 2.20k| { 1651| 2.20k| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 410| 2.20k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1652| 2.20k| yyrestart( yyin , yyscanner); ------------------ | | 98| 2.20k|#define yyrestart igraph_dl_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 356| 2.20k|#define yyin yyg->yyin_r ------------------ 1653| 2.20k| } 1654| | 1655| 2.05k| else 1656| 2.05k| { 1657| 2.05k| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 411| 2.05k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1658| 2.05k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 527| 2.05k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1659| 2.05k| YY_BUFFER_EOF_PENDING; ------------------ | | 510| 2.05k|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1660| 2.05k| } 1661| 4.25k| } 1662| | 1663| 7.21k| else 1664| 7.21k| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 409| 7.21k|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1665| | 1666| 11.4k| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1666:6): [True: 0, False: 11.4k] ------------------ 1667| | /* Extend the array by 50%, plus the number we really need. */ 1668| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1669| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 242| 0|#define yyrealloc igraph_dl_yyrealloc ------------------ 1670| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1671| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1671:8): [True: 0, False: 0] ------------------ 1672| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 891| 0|#define YY_FATAL_ERROR(msg) IGRAPH_FATAL("Error in DL parser: " # msg) | | ------------------ | | | | 895| 0| do { \ | | | | 896| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | | | 897| 0| } while (0) | | | | ------------------ | | | | | Branch (897:14): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1673| | /* "- 2" to take care of EOB's */ 1674| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 527| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1675| 0| } 1676| | 1677| 11.4k| yyg->yy_n_chars += number_to_move; 1678| 11.4k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 11.4k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1679| 11.4k| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 380| 11.4k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1680| | 1681| 11.4k| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 577| 11.4k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 527| 11.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1682| | 1683| 11.4k| return ret_val; 1684| 11.4k|} dl-lexer.c:yy_get_previous_state: 1689| 9.46k|{ 1690| 9.46k| yy_state_type yy_current_state; 1691| 9.46k| char *yy_cp; 1692| 9.46k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1693| | 1694| 9.46k| 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.46k|#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.46k|#define YY_MORE_ADJ 0 ------------------ | Branch (1696:47): [True: 262M, False: 9.46k] ------------------ 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: 61] ------------------ 1699| 262M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1699:8): [True: 261M, False: 1.57M] ------------------ 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.7M, False: 262M] ------------------ 1705| 53.7M| { 1706| 53.7M| yy_current_state = (int) yy_def[yy_current_state]; 1707| 53.7M| if ( yy_current_state >= 129 ) ------------------ | Branch (1707:9): [True: 52.2M, False: 1.44M] ------------------ 1708| 52.2M| yy_c = yy_meta[yy_c]; 1709| 53.7M| } 1710| 262M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1711| 262M| } 1712| | 1713| 9.46k| return yy_current_state; 1714| 9.46k|} dl-lexer.c:yy_try_NUL_trans: 1722| 195|{ 1723| 195| int yy_is_jam; 1724| 195| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ 1725| 195| char *yy_cp = yyg->yy_c_buf_p; 1726| | 1727| 195| YY_CHAR yy_c = 46; 1728| 195| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1728:7): [True: 111, False: 84] ------------------ 1729| 111| { 1730| 111| yyg->yy_last_accepting_state = yy_current_state; 1731| 111| yyg->yy_last_accepting_cpos = yy_cp; 1732| 111| } 1733| 399| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1733:10): [True: 204, False: 195] ------------------ 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| 195| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1740| 195| yy_is_jam = (yy_current_state == 128); 1741| | 1742| 195| (void)yyg; 1743| 195| return yy_is_jam ? 0 : yy_current_state; ------------------ | Branch (1743:9): [True: 129, False: 66] ------------------ 1744| 195|} dl-lexer.c:igraph_dl_yy_load_buffer_state: 1888| 6.71k|{ 1889| 6.71k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1890| 6.71k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 527| 6.71k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1891| 6.71k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 577| 6.71k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 527| 6.71k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1892| 6.71k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 356| 6.71k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 527| 6.71k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1893| 6.71k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1894| 6.71k|} dl-lexer.c:igraph_dl_yy_init_buffer: 1952| 4.51k|{ 1953| 4.51k| int oerrno = errno; 1954| 4.51k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1955| | 1956| 4.51k| yy_flush_buffer( b , yyscanner); ------------------ | | 56| 4.51k|#define yy_flush_buffer igraph_dl_yy_flush_buffer ------------------ 1957| | 1958| 4.51k| b->yy_input_file = file; 1959| 4.51k| 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.51k| if (b != YY_CURRENT_BUFFER){ ------------------ | | 521| 4.51k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (521:29): [True: 4.51k, False: 0] | | ------------------ | | 522| 4.51k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 523| 4.51k| : NULL) ------------------ | Branch (1965:9): [True: 2.31k, False: 2.20k] ------------------ 1966| 2.31k| b->yy_bs_lineno = 1; 1967| 2.31k| b->yy_bs_column = 0; 1968| 2.31k| } 1969| | 1970| 4.51k| b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ------------------ | Branch (1970:32): [True: 4.51k, False: 0] ------------------ 1971| | 1972| | errno = oerrno; 1973| 4.51k|} dl-lexer.c:igraph_dl_yyensure_buffer_stack: 2061| 2.31k|{ 2062| 2.31k| yy_size_t num_to_alloc; 2063| 2.31k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2064| | 2065| 2.31k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2065:6): [True: 2.31k, 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.31k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2072| 2.31k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 236| 2.31k|#define yyalloc igraph_dl_yyalloc ------------------ 2073| 2.31k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2074| 2.31k| , yyscanner); 2075| 2.31k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2075:8): [True: 0, False: 2.31k] ------------------ 2076| 2.31k| 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.31k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2079| | 2080| 2.31k| yyg->yy_buffer_stack_max = num_to_alloc; 2081| 2.31k| yyg->yy_buffer_stack_top = 0; 2082| 2.31k| return; 2083| 2.31k| } 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.62k|{ 2451| 4.62k| 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.62k| yyg->yy_buffer_stack = NULL; 2457| 4.62k| yyg->yy_buffer_stack_top = 0; 2458| 4.62k| yyg->yy_buffer_stack_max = 0; 2459| 4.62k| yyg->yy_c_buf_p = NULL; 2460| 4.62k| yyg->yy_init = 0; 2461| 4.62k| yyg->yy_start = 0; 2462| | 2463| 4.62k| yyg->yy_start_stack_ptr = 0; 2464| 4.62k| yyg->yy_start_stack_depth = 0; 2465| 4.62k| 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.62k| yyin = NULL; ------------------ | | 356| 4.62k|#define yyin yyg->yyin_r ------------------ 2473| 4.62k| yyout = NULL; ------------------ | | 357| 4.62k|#define yyout yyg->yyout_r ------------------ 2474| 4.62k|#endif 2475| | 2476| | /* For future reference: Set errno on error, since we are called by 2477| | * yylex_init() 2478| | */ 2479| 4.62k| return 0; 2480| 4.62k|} igraph_dl_yyparse: 1291| 2.31k|{ 1292| |/* The lookahead symbol. */ 1293| 2.31k|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.31k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 370| 2.31k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1300| 2.31k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 370| 2.31k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1301| | 1302| |/* Location data for the lookahead symbol. */ 1303| 2.31k|static YYLTYPE yyloc_default 1304| 2.31k|# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1305| 2.31k| = { 1, 1, 1, 1 } 1306| 2.31k|# endif 1307| 2.31k|; 1308| 2.31k|YYLTYPE yylloc = yyloc_default; 1309| | 1310| | /* Number of syntax errors so far. */ 1311| 2.31k| int yynerrs; 1312| | 1313| 2.31k| yy_state_fast_t yystate; 1314| | /* Number of tokens to shift before error messages enabled. */ 1315| 2.31k| 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.31k| yy_state_t yyssa[YYINITDEPTH]; 1327| 2.31k| yy_state_t *yyss; 1328| 2.31k| yy_state_t *yyssp; 1329| | 1330| | /* The semantic value stack. */ 1331| 2.31k| YYSTYPE yyvsa[YYINITDEPTH]; 1332| 2.31k| YYSTYPE *yyvs; 1333| 2.31k| YYSTYPE *yyvsp; 1334| | 1335| | /* The location stack. */ 1336| 2.31k| YYLTYPE yylsa[YYINITDEPTH]; 1337| 2.31k| YYLTYPE *yyls; 1338| 2.31k| YYLTYPE *yylsp; 1339| | 1340| | /* The locations where the error started and ended. */ 1341| 2.31k| YYLTYPE yyerror_range[3]; 1342| | 1343| 2.31k| YYPTRDIFF_T yystacksize; ------------------ | | 285| 2.31k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1344| | 1345| 2.31k| int yyn; 1346| 2.31k| int yyresult; 1347| | /* Lookahead token as an internal (translated) token number. */ 1348| 2.31k| int yytoken = 0; 1349| | /* The variables used to return semantic value and location from the 1350| | action routines. */ 1351| 2.31k| YYSTYPE yyval; 1352| 2.31k| YYLTYPE yyloc; 1353| | 1354| 2.31k|#if YYERROR_VERBOSE 1355| | /* Buffer for error messages, and its allocated size. */ 1356| 2.31k| char yymsgbuf[128]; 1357| 2.31k| char *yymsg = yymsgbuf; 1358| 2.31k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 285| 2.31k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1359| 2.31k|#endif 1360| | 1361| 2.31k|#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.31k| int yylen = 0; 1366| | 1367| 2.31k| yyssp = yyss = yyssa; 1368| 2.31k| yyvsp = yyvs = yyvsa; 1369| 2.31k| yylsp = yyls = yylsa; 1370| 2.31k| yystacksize = YYINITDEPTH; ------------------ | | 1016| 2.31k|# define YYINITDEPTH 200 ------------------ 1371| | 1372| 2.31k| YYDPRINTF ((stderr, "Starting parse\n")); 1373| | 1374| 2.31k| yystate = 0; 1375| 2.31k| yyerrstatus = 0; 1376| 2.31k| yynerrs = 0; ------------------ | | 71| 2.31k|#define yynerrs igraph_dl_yynerrs ------------------ 1377| 2.31k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 780| 2.31k|#define YYEMPTY (-2) ------------------ 1378| 2.31k| yylsp[0] = yylloc; 1379| 2.31k| goto yysetstate; 1380| | 1381| | 1382| |/*------------------------------------------------------------. 1383| || yynewstate -- push a new state, which is found in yystate. | 1384| |`------------------------------------------------------------*/ 1385| 26.4M|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.4M| yyssp++; 1389| | 1390| | 1391| |/*--------------------------------------------------------------------. 1392| || yysetstate -- set current state (the top of the stack) to yystate. | 1393| |`--------------------------------------------------------------------*/ 1394| 26.4M|yysetstate: 1395| 26.4M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1396| 26.4M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 393| 26.4M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (393:31): [Folded, False: 26.4M] | | | Branch (393:37): [True: 0, False: 0] | | | Branch (393:37): [True: 0, False: 0] | | ------------------ ------------------ 1397| 26.4M| YY_IGNORE_USELESS_CAST_BEGIN 1398| 26.4M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 126| 26.4M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1399| 26.4M| YY_IGNORE_USELESS_CAST_END 1400| | 1401| 26.4M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1401:7): [True: 0, False: 26.4M] ------------------ 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.4M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1468| | 1469| 26.4M| if (yystate == YYFINAL) ------------------ | | 527| 26.4M|#define YYFINAL 4 ------------------ | Branch (1469:7): [True: 813, False: 26.4M] ------------------ 1470| 813| YYACCEPT; ------------------ | | 783| 813|#define YYACCEPT goto yyacceptlab ------------------ 1471| | 1472| 26.4M| goto yybackup; 1473| | 1474| | 1475| |/*-----------. 1476| || yybackup. | 1477| |`-----------*/ 1478| 26.4M|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.4M| yyn = yypact[yystate]; 1484| 26.4M| if (yypact_value_is_default (yyn)) ------------------ | | 632| 26.4M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 26.4M|#define YYPACT_NINF (-114) | | ------------------ | | | Branch (632:3): [True: 14.4M, False: 11.9M] | | ------------------ ------------------ 1485| 14.4M| goto yydefault; 1486| | 1487| | /* Not known => get a lookahead token if don't already have one. */ 1488| | 1489| | /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1490| 11.9M| if (yychar == YYEMPTY) ------------------ | | 780| 11.9M|#define YYEMPTY (-2) ------------------ | Branch (1490:7): [True: 10.5M, False: 1.44M] ------------------ 1491| 10.5M| { 1492| 10.5M| YYDPRINTF ((stderr, "Reading a token: ")); 1493| 10.5M| yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 68| 10.5M|#define yylex igraph_dl_yylex ------------------ yychar = yylex (&yylval, &yylloc, scanner); ------------------ | | 116| 10.5M|#define scanner context->scanner ------------------ 1494| 10.5M| } 1495| | 1496| 11.9M| if (yychar <= YYEOF) ------------------ | | 781| 11.9M|#define YYEOF 0 ------------------ | Branch (1496:7): [True: 1.01k, False: 11.9M] ------------------ 1497| 1.01k| { 1498| 1.01k| yychar = yytoken = YYEOF; ------------------ | | 781| 1.01k|#define YYEOF 0 ------------------ 1499| 1.01k| YYDPRINTF ((stderr, "Now at end of input.\n")); 1500| 1.01k| } 1501| 11.9M| else 1502| 11.9M| { 1503| 11.9M| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 11.9M| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 11.9M|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 11.9M, False: 0] | | | Branch (547:18): [True: 11.9M, False: 0] | | ------------------ ------------------ 1504| 11.9M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1505| 11.9M| } 1506| | 1507| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1508| | detect an error, take that action. */ 1509| 11.9M| yyn += yytoken; 1510| 11.9M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 529| 11.9M|#define YYLAST 118 ------------------ | Branch (1510:7): [True: 0, False: 11.9M] | Branch (1510:18): [True: 0, False: 11.9M] | Branch (1510:34): [True: 1.43M, False: 10.5M] ------------------ 1511| 1.43M| goto yydefault; 1512| 10.5M| yyn = yytable[yyn]; 1513| 10.5M| if (yyn <= 0) ------------------ | Branch (1513:7): [True: 12.8k, False: 10.5M] ------------------ 1514| 12.8k| { 1515| 12.8k| if (yytable_value_is_error (yyn)) ------------------ | | 637| 12.8k| 0 | | ------------------ | | | Branch (637:3): [Folded, False: 12.8k] | | ------------------ ------------------ 1516| 0| goto yyerrlab; 1517| 12.8k| yyn = -yyn; 1518| 12.8k| goto yyreduce; 1519| 12.8k| } 1520| | 1521| | /* Count tokens shifted since error; after three, turn off error 1522| | status. */ 1523| 10.5M| if (yyerrstatus) ------------------ | Branch (1523:7): [True: 0, False: 10.5M] ------------------ 1524| 0| yyerrstatus--; 1525| | 1526| | /* Shift the lookahead token. */ 1527| 10.5M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1528| 10.5M| yystate = yyn; 1529| 10.5M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1530| 10.5M| *++yyvsp = yylval; 1531| 10.5M| YY_IGNORE_MAYBE_UNINITIALIZED_END 1532| 10.5M| *++yylsp = yylloc; 1533| | 1534| | /* Discard the shifted token. */ 1535| 10.5M| yychar = YYEMPTY; ------------------ | | 780| 10.5M|#define YYEMPTY (-2) ------------------ 1536| 10.5M| goto yynewstate; 1537| | 1538| | 1539| |/*-----------------------------------------------------------. 1540| || yydefault -- do the default action for the current state. | 1541| |`-----------------------------------------------------------*/ 1542| 15.8M|yydefault: 1543| 15.8M| yyn = yydefact[yystate]; 1544| 15.8M| if (yyn == 0) ------------------ | Branch (1544:7): [True: 818, False: 15.8M] ------------------ 1545| 818| goto yyerrlab; 1546| 15.8M| goto yyreduce; 1547| | 1548| | 1549| |/*-----------------------------. 1550| || yyreduce -- do a reduction. | 1551| |`-----------------------------*/ 1552| 15.9M|yyreduce: 1553| | /* yyn is the number of a rule to reduce with. */ 1554| 15.9M| yylen = yyr2[yyn]; 1555| | 1556| | /* If YYLEN is nonzero, implement the default value of the action: 1557| | '$$ = $1'. 1558| | 1559| | Otherwise, the following line sets YYVAL to garbage. 1560| | This behavior is undocumented and Bison 1561| | users should not rely upon it. Assigning to YYVAL 1562| | unconditionally makes the parser a bit smaller, and it avoids a 1563| | GCC warning that YYVAL may be used uninitialized. */ 1564| 15.9M| yyval = yyvsp[1-yylen]; 1565| | 1566| | /* Default location. */ 1567| 15.9M| YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); ------------------ | | 818| 15.9M| do \ | | 819| 15.9M| if (N) \ | | ------------------ | | | Branch (819:11): [True: 14.4M, False: 1.44M] | | ------------------ | | 820| 15.9M| { \ | | 821| 14.4M| (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ | | ------------------ | | | | 836| 14.4M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 822| 14.4M| (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ | | ------------------ | | | | 836| 14.4M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 823| 14.4M| (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ | | ------------------ | | | | 836| 14.4M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 824| 14.4M| (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ | | ------------------ | | | | 836| 14.4M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 825| 14.4M| } \ | | 826| 15.9M| else \ | | 827| 15.9M| { \ | | 828| 1.44M| (Current).first_line = (Current).last_line = \ | | 829| 1.44M| YYRHSLOC (Rhs, 0).last_line; \ | | ------------------ | | | | 836| 1.44M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 830| 1.44M| (Current).first_column = (Current).last_column = \ | | 831| 1.44M| YYRHSLOC (Rhs, 0).last_column; \ | | ------------------ | | | | 836| 1.44M|#define YYRHSLOC(Rhs, K) ((Rhs)[K]) | | ------------------ | | 832| 1.44M| } \ | | 833| 15.9M| while (0) | | ------------------ | | | Branch (833:12): [Folded, False: 15.9M] | | ------------------ ------------------ 1568| 15.9M| yyerror_range[1] = yyloc; 1569| 15.9M| YY_REDUCE_PRINT (yyn); 1570| 15.9M| switch (yyn) 1571| 15.9M| { 1572| 896| case 2: ------------------ | Branch (1572:3): [True: 896, False: 15.9M] ------------------ 1573| 896|#line 104 "/src/igraph/src/io/dl-parser.y" 1574| 896| { 1575| 896| context->n=(yyvsp[-4].integer); 1576| 896| if (context->n < 0) { ------------------ | Branch (1576:7): [True: 0, False: 896] ------------------ 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| 896| if (context->n > IGRAPH_DL_MAX_VERTEX_COUNT) { ------------------ | | 31| 896|#define IGRAPH_DL_MAX_VERTEX_COUNT (1 << 20) ------------------ | Branch (1579:7): [True: 46, False: 850] ------------------ 1580| 46| IGRAPH_YY_ERRORF("Vertex count too large in DL file (%" IGRAPH_PRId ").", IGRAPH_EINVAL, context->n); ------------------ | | 24| 46| do { \ | | 25| 46| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 46| error_code, __VA_ARGS__) ; \ | | 27| 46| context->igraph_errno = error_code; \ | | 28| 46| YYABORT; \ | | ------------------ | | | | 784| 46|#define YYABORT goto yyabortlab | | ------------------ | | 29| 46| } while (0) | | ------------------ | | | Branch (29:14): [Folded, False: 0] | | ------------------ ------------------ 1581| 46| } 1582| 896|} 1583| 850|#line 1584 "/src/igraph/build/src/io/parsers/dl-parser.c" 1584| 850| break; 1585| | 1586| 850| case 7: ------------------ | Branch (1586:3): [True: 440, False: 15.9M] ------------------ 1587| 440|#line 118 "/src/igraph/src/io/dl-parser.y" 1588| 440| { context->type=IGRAPH_DL_MATRIX; } 1589| 440|#line 1590 "/src/igraph/build/src/io/parsers/dl-parser.c" 1590| 440| break; 1591| | 1592| 346| case 8: ------------------ | Branch (1592:3): [True: 346, False: 15.9M] ------------------ 1593| 346|#line 119 "/src/igraph/src/io/dl-parser.y" 1594| 346| { context->type=IGRAPH_DL_EDGELIST1; } 1595| 346|#line 1596 "/src/igraph/build/src/io/parsers/dl-parser.c" 1596| 346| break; 1597| | 1598| 110| case 9: ------------------ | Branch (1598:3): [True: 110, False: 15.9M] ------------------ 1599| 110|#line 120 "/src/igraph/src/io/dl-parser.y" 1600| 110| { context->type=IGRAPH_DL_NODELIST1; } 1601| 110|#line 1602 "/src/igraph/build/src/io/parsers/dl-parser.c" 1602| 110| break; 1603| | 1604| 0| case 10: ------------------ | Branch (1604:3): [True: 0, False: 15.9M] ------------------ 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| 440| case 11: ------------------ | Branch (1610:3): [True: 440, False: 15.9M] ------------------ 1611| 440|#line 123 "/src/igraph/src/io/dl-parser.y" 1612| 440| {} 1613| 440|#line 1614 "/src/igraph/build/src/io/parsers/dl-parser.c" 1614| 440| break; 1615| | 1616| 348| case 14: ------------------ | Branch (1616:3): [True: 348, False: 15.9M] ------------------ 1617| 348|#line 127 "/src/igraph/src/io/dl-parser.y" 1618| 348| { } 1619| 348|#line 1620 "/src/igraph/build/src/io/parsers/dl-parser.c" 1620| 348| break; 1621| | 1622| 77| case 15: ------------------ | Branch (1622:3): [True: 77, False: 15.9M] ------------------ 1623| 77|#line 128 "/src/igraph/src/io/dl-parser.y" 1624| 77| { } 1625| 77|#line 1626 "/src/igraph/build/src/io/parsers/dl-parser.c" 1626| 77| break; 1627| | 1628| 15| case 16: ------------------ | Branch (1628:3): [True: 15, False: 15.9M] ------------------ 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| 332| case 17: ------------------ | Branch (1634:3): [True: 332, False: 15.9M] ------------------ 1635| 332|#line 132 "/src/igraph/src/io/dl-parser.y" 1636| 332| {} 1637| 332|#line 1638 "/src/igraph/build/src/io/parsers/dl-parser.c" 1638| 332| break; 1639| | 1640| 1.61M| case 18: ------------------ | Branch (1640:3): [True: 1.61M, False: 14.2M] ------------------ 1641| 1.61M|#line 133 "/src/igraph/src/io/dl-parser.y" 1642| 1.61M| { 1643| 1.61M| IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.61M| do { \ | | 11| 1.61M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.61M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.61M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.61M] | | | | ------------------ | | ------------------ | | 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.61M| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.61M] | | ------------------ ------------------ 1644| 1.61M| igraph_dl_yyget_leng(scanner), 1645| 1.61M| context)); } 1646| 1.61M|#line 1647 "/src/igraph/build/src/io/parsers/dl-parser.c" 1647| 1.61M| break; 1648| | 1649| 1.61M| case 19: ------------------ | Branch (1649:3): [True: 454, False: 15.9M] ------------------ 1650| 454|#line 139 "/src/igraph/src/io/dl-parser.y" 1651| 454| {} 1652| 454|#line 1653 "/src/igraph/build/src/io/parsers/dl-parser.c" 1653| 454| break; 1654| | 1655| 12.8k| case 20: ------------------ | Branch (1655:3): [True: 12.8k, False: 15.8M] ------------------ 1656| 12.8k|#line 139 "/src/igraph/src/io/dl-parser.y" 1657| 12.8k| { 1658| 12.8k| context->from += 1; 1659| 12.8k| context->to = 0; 1660| 12.8k| } 1661| 12.8k|#line 1662 "/src/igraph/build/src/io/parsers/dl-parser.c" 1662| 12.8k| break; 1663| | 1664| 58.4k| case 22: ------------------ | Branch (1664:3): [True: 58.4k, False: 15.8M] ------------------ 1665| 58.4k|#line 144 "/src/igraph/src/io/dl-parser.y" 1666| 58.4k| { } 1667| 58.4k|#line 1668 "/src/igraph/build/src/io/parsers/dl-parser.c" 1668| 58.4k| break; 1669| | 1670| 58.4k| case 23: ------------------ | Branch (1670:3): [True: 58.4k, False: 15.8M] ------------------ 1671| 58.4k|#line 146 "/src/igraph/src/io/dl-parser.y" 1672| 58.4k| { 1673| | /* TODO: What if the digit is neither 0 or 1? Are multigraphs allowed? */ 1674| 58.4k| char c = igraph_dl_yyget_text(scanner)[0]; ------------------ | | 116| 58.4k|#define scanner context->scanner ------------------ 1675| 58.4k| if (c == '1') { ------------------ | Branch (1675:7): [True: 57.5k, False: 885] ------------------ 1676| 57.5k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 57.5k| do { \ | | 11| 57.5k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 57.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 57.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 57.5k] | | | | ------------------ | | ------------------ | | 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| 57.5k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 57.5k] | | ------------------ ------------------ 1677| 57.5k| context->from)); 1678| 57.5k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 57.5k| do { \ | | 11| 57.5k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 57.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 57.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 57.5k] | | | | ------------------ | | ------------------ | | 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| 57.5k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 57.5k] | | ------------------ ------------------ 1679| 57.5k| context->to)); 1680| 57.5k| } else if (c != '0') { ------------------ | Branch (1680:14): [True: 5, False: 880] ------------------ 1681| 5| IGRAPH_YY_ERRORF("Unexpected digit '%c' in adjacency matrix in DL file.", ------------------ | | 24| 5| do { \ | | 25| 5| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 26| 5| error_code, __VA_ARGS__) ; \ | | 27| 5| context->igraph_errno = error_code; \ | | 28| 5| YYABORT; \ | | ------------------ | | | | 784| 5|#define YYABORT goto yyabortlab | | ------------------ | | 29| 5| } while (0) | | ------------------ | | | Branch (29:14): [Folded, False: 0] | | ------------------ ------------------ 1682| 5| IGRAPH_EINVAL, c); 1683| 5| } 1684| 58.4k| context->to += 1; 1685| 58.4k|} 1686| 0|#line 1687 "/src/igraph/build/src/io/parsers/dl-parser.c" 1687| 0| break; 1688| | 1689| 15| case 24: ------------------ | Branch (1689:3): [True: 15, False: 15.9M] ------------------ 1690| 15|#line 161 "/src/igraph/src/io/dl-parser.y" 1691| 15| {} 1692| 15|#line 1693 "/src/igraph/build/src/io/parsers/dl-parser.c" 1693| 15| break; 1694| | 1695| 15| case 25: ------------------ | Branch (1695:3): [True: 15, False: 15.9M] ------------------ 1696| 15|#line 163 "/src/igraph/src/io/dl-parser.y" 1697| 15| {} 1698| 15|#line 1699 "/src/igraph/build/src/io/parsers/dl-parser.c" 1699| 15| break; 1700| | 1701| 1.99k| case 28: ------------------ | Branch (1701:3): [True: 1.99k, False: 15.9M] ------------------ 1702| 1.99k|#line 167 "/src/igraph/src/io/dl-parser.y" 1703| 1.99k| { IGRAPH_YY_CHECK(igraph_i_dl_add_str(igraph_dl_yyget_text(scanner), ------------------ | | 10| 1.99k| do { \ | | 11| 1.99k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.99k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.99k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.99k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 1.99k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 1.99k] | | ------------------ ------------------ 1704| 1.99k| igraph_dl_yyget_leng(scanner), 1705| 1.99k| context)); } 1706| 1.99k|#line 1707 "/src/igraph/build/src/io/parsers/dl-parser.c" 1707| 1.99k| break; 1708| | 1709| 1.99k| case 29: ------------------ | Branch (1709:3): [True: 17, False: 15.9M] ------------------ 1710| 17|#line 171 "/src/igraph/src/io/dl-parser.y" 1711| 17| { 1712| 17| context->from += 1; 1713| 17| context->to = 0; 1714| 17| } 1715| 17|#line 1716 "/src/igraph/build/src/io/parsers/dl-parser.c" 1716| 17| break; 1717| | 1718| 195| case 30: ------------------ | Branch (1718:3): [True: 195, False: 15.9M] ------------------ 1719| 195|#line 175 "/src/igraph/src/io/dl-parser.y" 1720| 195| { 1721| 195| context->from += 1; 1722| 195| context->to = 0; 1723| 195| } 1724| 195|#line 1725 "/src/igraph/build/src/io/parsers/dl-parser.c" 1725| 195| break; 1726| | 1727| 212| case 31: ------------------ | Branch (1727:3): [True: 212, False: 15.9M] ------------------ 1728| 212|#line 180 "/src/igraph/src/io/dl-parser.y" 1729| 212| { } 1730| 212|#line 1731 "/src/igraph/build/src/io/parsers/dl-parser.c" 1731| 212| break; 1732| | 1733| 346| case 32: ------------------ | Branch (1733:3): [True: 346, False: 15.9M] ------------------ 1734| 346|#line 184 "/src/igraph/src/io/dl-parser.y" 1735| 346| {} 1736| 346|#line 1737 "/src/igraph/build/src/io/parsers/dl-parser.c" 1737| 346| break; 1738| | 1739| 318| case 33: ------------------ | Branch (1739:3): [True: 318, False: 15.9M] ------------------ 1740| 318|#line 186 "/src/igraph/src/io/dl-parser.y" 1741| 318| {} 1742| 318|#line 1743 "/src/igraph/build/src/io/parsers/dl-parser.c" 1743| 318| break; 1744| | 1745| 3| case 34: ------------------ | Branch (1745:3): [True: 3, False: 15.9M] ------------------ 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| 19| case 35: ------------------ | Branch (1751:3): [True: 19, False: 15.9M] ------------------ 1752| 19|#line 188 "/src/igraph/src/io/dl-parser.y" 1753| 19| {} 1754| 19|#line 1755 "/src/igraph/build/src/io/parsers/dl-parser.c" 1755| 19| break; 1756| | 1757| 6| case 36: ------------------ | Branch (1757:3): [True: 6, False: 15.9M] ------------------ 1758| 6|#line 189 "/src/igraph/src/io/dl-parser.y" 1759| 6| {} 1760| 6|#line 1761 "/src/igraph/build/src/io/parsers/dl-parser.c" 1761| 6| break; 1762| | 1763| 0| case 37: ------------------ | Branch (1763:3): [True: 0, False: 15.9M] ------------------ 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| 874| case 38: ------------------ | Branch (1769:3): [True: 874, False: 15.9M] ------------------ 1770| 874|#line 193 "/src/igraph/src/io/dl-parser.y" 1771| 874| {} 1772| 874|#line 1773 "/src/igraph/build/src/io/parsers/dl-parser.c" 1773| 874| break; 1774| | 1775| 2.34M| case 39: ------------------ | Branch (1775:3): [True: 2.34M, False: 13.5M] ------------------ 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: 15.8M] ------------------ 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: 121, False: 38.5k] | | | | ------------------ | | ------------------ | | 13| 121| context->igraph_errno = igraph_i_ret; \ | | 14| 121| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 121|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 121| YYABORT; \ | | ------------------ | | | | 784| 121|#define YYABORT goto yyabortlab | | ------------------ | | 16| 121| } \ | | 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: 131, False: 38.4k] | | | | ------------------ | | ------------------ | | 13| 131| context->igraph_errno = igraph_i_ret; \ | | 14| 131| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 131|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 131| YYABORT; \ | | ------------------ | | | | 784| 131|#define YYABORT goto yyabortlab | | ------------------ | | 16| 131| } \ | | 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.5M] ------------------ 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: 121, False: 2.30M] | | | | ------------------ | | ------------------ | | 13| 121| context->igraph_errno = igraph_i_ret; \ | | 14| 121| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 121|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 121| YYABORT; \ | | ------------------ | | | | 784| 121|#define YYABORT goto yyabortlab | | ------------------ | | 16| 121| } \ | | 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: 83, False: 2.30M] | | | | ------------------ | | ------------------ | | 13| 83| context->igraph_errno = igraph_i_ret; \ | | 14| 83| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 83|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 83| YYABORT; \ | | ------------------ | | | | 784| 83|#define YYABORT goto yyabortlab | | ------------------ | | 16| 83| } \ | | 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.68M] ------------------ 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: 32, False: 6.21M] | | | | ------------------ | | ------------------ | | 13| 32| context->igraph_errno = igraph_i_ret; \ | | 14| 32| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 32|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 32| YYABORT; \ | | ------------------ | | | | 784| 32|#define YYABORT goto yyabortlab | | ------------------ | | 16| 32| } \ | | 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| 112| case 43: ------------------ | Branch (1814:3): [True: 112, False: 15.9M] ------------------ 1815| 112|#line 217 "/src/igraph/src/io/dl-parser.y" 1816| 112| {} 1817| 112|#line 1818 "/src/igraph/build/src/io/parsers/dl-parser.c" 1818| 112| break; 1819| | 1820| 636| case 44: ------------------ | Branch (1820:3): [True: 636, False: 15.9M] ------------------ 1821| 636|#line 218 "/src/igraph/src/io/dl-parser.y" 1822| 636| {} 1823| 636|#line 1824 "/src/igraph/build/src/io/parsers/dl-parser.c" 1824| 636| break; 1825| | 1826| 195| case 45: ------------------ | Branch (1826:3): [True: 195, False: 15.9M] ------------------ 1827| 195|#line 221 "/src/igraph/src/io/dl-parser.y" 1828| 195| { 1829| 195| IGRAPH_YY_CHECK(igraph_i_dl_add_edge_w((yyvsp[-3].integer), (yyvsp[-2].integer), (yyvsp[-1].real), context)); } ------------------ | | 10| 195| do { \ | | 11| 195| igraph_error_t igraph_i_ret = (expr); \ | | 12| 195| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 195| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 195] | | | | ------------------ | | ------------------ | | 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| 195| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 195] | | ------------------ ------------------ 1830| 195|#line 1831 "/src/igraph/build/src/io/parsers/dl-parser.c" 1831| 195| break; 1832| | 1833| 441| case 46: ------------------ | Branch (1833:3): [True: 441, False: 15.9M] ------------------ 1834| 441|#line 223 "/src/igraph/src/io/dl-parser.y" 1835| 441| { 1836| 441| IGRAPH_YY_CHECK(igraph_i_dl_add_edge((yyvsp[-2].integer), (yyvsp[-1].integer), context)); ------------------ | | 10| 441| do { \ | | 11| 441| igraph_error_t igraph_i_ret = (expr); \ | | 12| 441| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 441| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 441] | | | | ------------------ | | ------------------ | | 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| 441| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 441] | | ------------------ ------------------ 1837| 441| } 1838| 441|#line 1839 "/src/igraph/build/src/io/parsers/dl-parser.c" 1839| 441| break; 1840| | 1841| 38.9k| case 47: ------------------ | Branch (1841:3): [True: 38.9k, False: 15.8M] ------------------ 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: 24, False: 38.9k] | | | | ------------------ | | ------------------ | | 13| 24| context->igraph_errno = igraph_i_ret; \ | | 14| 24| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 24|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 24| YYABORT; \ | | ------------------ | | | | 784| 24|#define YYABORT goto yyabortlab | | ------------------ | | 16| 24| } \ | | 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| 8.87k| case 48: ------------------ | Branch (1853:3): [True: 8.87k, False: 15.8M] ------------------ 1854| 8.87k|#line 235 "/src/igraph/src/io/dl-parser.y" 1855| 8.87k| { 1856| 8.87k| igraph_int_t trie_id; 1857| | 1858| | /* Copy label list to trie, if needed */ 1859| 8.87k| if (igraph_strvector_size(&context->labels) != 0) { ------------------ | Branch (1859:7): [True: 148, False: 8.72k] ------------------ 1860| 148| igraph_int_t i, id, n=igraph_strvector_size(&context->labels); 1861| 542k| for (i=0; itrie, igraph_strvector_get(&context->labels, i), &id)); ------------------ | | 10| 541k| do { \ | | 11| 541k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 541k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 541k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 541k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 541k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 541k] | | ------------------ ------------------ 1863| 541k| } 1864| 148| igraph_strvector_clear(&context->labels); 1865| 148| } 1866| 8.87k| IGRAPH_YY_CHECK(igraph_trie_get_len(&context->trie, igraph_dl_yyget_text(scanner), ------------------ | | 10| 8.87k| do { \ | | 11| 8.87k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 8.87k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 8.87k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.87k] | | | | ------------------ | | ------------------ | | 13| 0| context->igraph_errno = igraph_i_ret; \ | | 14| 0| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 0|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 0| YYABORT; \ | | ------------------ | | | | 784| 0|#define YYABORT goto yyabortlab | | ------------------ | | 16| 0| } \ | | 17| 8.87k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 8.87k] | | ------------------ ------------------ 1867| 8.87k| igraph_dl_yyget_leng(scanner), &trie_id)); 1868| 8.87k| IGRAPH_ASSERT(0 <= trie_id && trie_id < IGRAPH_DL_MAX_VERTEX_COUNT); ------------------ | | 924| 8.87k| do { \ | | 925| 8.87k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.87k] | | | | | Branch (612:52): [True: 8.87k, False: 0] | | | | | Branch (612:52): [True: 8.87k, False: 0] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.87k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.87k] | | ------------------ ------------------ 1869| 8.87k| (yyval.integer) = trie_id; 1870| 8.87k| } 1871| 0|#line 1872 "/src/igraph/build/src/io/parsers/dl-parser.c" 1872| 0| break; 1873| | 1874| 110| case 49: ------------------ | Branch (1874:3): [True: 110, False: 15.9M] ------------------ 1875| 110|#line 254 "/src/igraph/src/io/dl-parser.y" 1876| 110| {} 1877| 110|#line 1878 "/src/igraph/build/src/io/parsers/dl-parser.c" 1878| 110| break; 1879| | 1880| 59| case 50: ------------------ | Branch (1880:3): [True: 59, False: 15.9M] ------------------ 1881| 59|#line 256 "/src/igraph/src/io/dl-parser.y" 1882| 59| {} 1883| 59|#line 1884 "/src/igraph/build/src/io/parsers/dl-parser.c" 1884| 59| break; 1885| | 1886| 1| case 51: ------------------ | Branch (1886:3): [True: 1, False: 15.9M] ------------------ 1887| 1|#line 257 "/src/igraph/src/io/dl-parser.y" 1888| 1| {} 1889| 1|#line 1890 "/src/igraph/build/src/io/parsers/dl-parser.c" 1890| 1| break; 1891| | 1892| 34| case 52: ------------------ | Branch (1892:3): [True: 34, False: 15.9M] ------------------ 1893| 34|#line 258 "/src/igraph/src/io/dl-parser.y" 1894| 34| {} 1895| 34|#line 1896 "/src/igraph/build/src/io/parsers/dl-parser.c" 1896| 34| break; 1897| | 1898| 16| case 53: ------------------ | Branch (1898:3): [True: 16, False: 15.9M] ------------------ 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: 15.9M] ------------------ 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| 283| case 55: ------------------ | Branch (1910:3): [True: 283, False: 15.9M] ------------------ 1911| 283|#line 263 "/src/igraph/src/io/dl-parser.y" 1912| 283| {} 1913| 283|#line 1914 "/src/igraph/build/src/io/parsers/dl-parser.c" 1914| 283| break; 1915| | 1916| 490| case 56: ------------------ | Branch (1916:3): [True: 490, False: 15.9M] ------------------ 1917| 490|#line 264 "/src/igraph/src/io/dl-parser.y" 1918| 490| {} 1919| 490|#line 1920 "/src/igraph/build/src/io/parsers/dl-parser.c" 1920| 490| break; 1921| | 1922| 490| case 57: ------------------ | Branch (1922:3): [True: 490, False: 15.9M] ------------------ 1923| 490|#line 267 "/src/igraph/src/io/dl-parser.y" 1924| 490| {} 1925| 490|#line 1926 "/src/igraph/build/src/io/parsers/dl-parser.c" 1926| 490| break; 1927| | 1928| 713| case 58: ------------------ | Branch (1928:3): [True: 713, False: 15.9M] ------------------ 1929| 713|#line 269 "/src/igraph/src/io/dl-parser.y" 1930| 713| { 1931| 713| IGRAPH_YY_CHECK(igraph_i_parse_integer(igraph_dl_yyget_text(scanner), ------------------ | | 10| 713| do { \ | | 11| 713| igraph_error_t igraph_i_ret = (expr); \ | | 12| 713| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 713| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 9, False: 704] | | | | ------------------ | | ------------------ | | 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| 713| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 704] | | ------------------ ------------------ 1932| 713| igraph_dl_yyget_leng(scanner), 1933| 713| &context->from)); 1934| 704| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(context->from)); ------------------ | | 10| 704| do { \ | | 11| 704| igraph_error_t igraph_i_ret = (expr); \ | | 12| 704| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 704| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 54, False: 650] | | | | ------------------ | | ------------------ | | 13| 54| context->igraph_errno = igraph_i_ret; \ | | 14| 54| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 54|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 54| YYABORT; \ | | ------------------ | | | | 784| 54|#define YYABORT goto yyabortlab | | ------------------ | | 16| 54| } \ | | 17| 704| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 650] | | ------------------ ------------------ 1935| 704|} 1936| 650|#line 1937 "/src/igraph/build/src/io/parsers/dl-parser.c" 1937| 650| break; 1938| | 1939| 650| case 59: ------------------ | Branch (1939:3): [True: 650, False: 15.9M] ------------------ 1940| 650|#line 276 "/src/igraph/src/io/dl-parser.y" 1941| 650| {} 1942| 650|#line 1943 "/src/igraph/build/src/io/parsers/dl-parser.c" 1943| 650| break; 1944| | 1945| 1.52M| case 60: ------------------ | Branch (1945:3): [True: 1.52M, False: 14.3M] ------------------ 1946| 1.52M|#line 276 "/src/igraph/src/io/dl-parser.y" 1947| 1.52M| { 1948| 1.52M| igraph_int_t to = (yyvsp[0].integer); 1949| 1.52M| IGRAPH_YY_CHECK(igraph_i_dl_check_vid(to)); ------------------ | | 10| 1.52M| do { \ | | 11| 1.52M| igraph_error_t igraph_i_ret = (expr); \ | | 12| 1.52M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 1.52M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 54, False: 1.52M] | | | | ------------------ | | ------------------ | | 13| 54| context->igraph_errno = igraph_i_ret; \ | | 14| 54| yyerror(&yylloc, context, "failed"); \ | | ------------------ | | | | 69| 54|#define yyerror igraph_dl_yyerror | | ------------------ | | 15| 54| YYABORT; \ | | ------------------ | | | | 784| 54|#define YYABORT goto yyabortlab | | ------------------ | | 16| 54| } \ | | 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: 230, False: 15.9M] ------------------ 1958| 230|#line 284 "/src/igraph/src/io/dl-parser.y" 1959| 230| {} 1960| 230|#line 1961 "/src/igraph/build/src/io/parsers/dl-parser.c" 1961| 230| break; 1962| | 1963| 3.45k| case 62: ------------------ | Branch (1963:3): [True: 3.45k, False: 15.8M] ------------------ 1964| 3.45k|#line 285 "/src/igraph/src/io/dl-parser.y" 1965| 3.45k| {} 1966| 3.45k|#line 1967 "/src/igraph/build/src/io/parsers/dl-parser.c" 1967| 3.45k| break; 1968| | 1969| 3.45k| case 63: ------------------ | Branch (1969:3): [True: 3.45k, False: 15.8M] ------------------ 1970| 3.45k|#line 288 "/src/igraph/src/io/dl-parser.y" 1971| 3.45k| { } 1972| 3.45k|#line 1973 "/src/igraph/build/src/io/parsers/dl-parser.c" 1973| 3.45k| break; 1974| | 1975| 3.63k| case 64: ------------------ | Branch (1975:3): [True: 3.63k, False: 15.8M] ------------------ 1976| 3.63k|#line 290 "/src/igraph/src/io/dl-parser.y" 1977| 3.63k| { 1978| 3.63k| context->from=(yyvsp[0].integer); 1979| 3.63k| } 1980| 3.63k|#line 1981 "/src/igraph/build/src/io/parsers/dl-parser.c" 1981| 3.63k| break; 1982| | 1983| 3.86k| case 66: ------------------ | Branch (1983:3): [True: 3.86k, False: 15.8M] ------------------ 1984| 3.86k|#line 294 "/src/igraph/src/io/dl-parser.y" 1985| 3.86k| { 1986| 3.86k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, ------------------ | | 10| 3.86k| do { \ | | 11| 3.86k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.86k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 3.86k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.86k] | | | | ------------------ | | ------------------ | | 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.86k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 3.86k] | | ------------------ ------------------ 1987| 3.86k| context->from)); 1988| 3.86k| IGRAPH_YY_CHECK(igraph_vector_int_push_back(&context->edges, (yyvsp[0].integer))); ------------------ | | 10| 3.86k| do { \ | | 11| 3.86k| igraph_error_t igraph_i_ret = (expr); \ | | 12| 3.86k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) { \ | | ------------------ | | | | 612| 3.86k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.86k] | | | | ------------------ | | ------------------ | | 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.86k| } while (0) | | ------------------ | | | Branch (17:14): [Folded, False: 3.86k] | | ------------------ ------------------ 1989| 3.86k| } 1990| 3.86k|#line 1991 "/src/igraph/build/src/io/parsers/dl-parser.c" 1991| 3.86k| break; 1992| | 1993| | 1994| 3.86k|#line 1995 "/src/igraph/build/src/io/parsers/dl-parser.c" 1995| | 1996| 1.64M| default: break; ------------------ | Branch (1996:7): [True: 1.64M, False: 14.2M] ------------------ 1997| 15.9M| } 1998| | /* User semantic actions sometimes alter yychar, and that requires 1999| | that yytoken be updated with the new translation. We take the 2000| | approach of translating immediately before every use of yytoken. 2001| | One alternative is translating here after every semantic action, 2002| | but that translation would be missed if the semantic action invokes 2003| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 2004| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 2005| | incorrect destructor might then be invoked immediately. In the 2006| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 2007| | to an incorrect destructor call or verbose syntax error message 2008| | before the lookahead is translated. */ 2009| 15.9M| YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2010| | 2011| 15.9M| YYPOPSTACK (yylen); ------------------ | | 1361| 15.9M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2012| 15.9M| yylen = 0; 2013| 15.9M| YY_STACK_PRINT (yyss, yyssp); 2014| | 2015| 15.9M| *++yyvsp = yyval; 2016| 15.9M| *++yylsp = yyloc; 2017| | 2018| | /* Now 'shift' the result of the reduction. Determine what state 2019| | that goes to, based on the state we popped back to and the rule 2020| | number reduced by. */ 2021| 15.9M| { 2022| 15.9M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 532| 15.9M|#define YYNTOKENS 17 ------------------ 2023| 15.9M| const int yyi = yypgoto[yylhs] + *yyssp; 2024| 15.9M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 529| 26.7M|#define YYLAST 118 ------------------ | Branch (2024:16): [True: 10.8M, False: 5.01M] | Branch (2024:28): [True: 10.8M, False: 196] | Branch (2024:45): [True: 6.06M, False: 4.81M] ------------------ 2025| 15.9M| ? yytable[yyi] 2026| 15.9M| : yydefgoto[yylhs]); 2027| 15.9M| } 2028| | 2029| 15.9M| goto yynewstate; 2030| | 2031| | 2032| |/*--------------------------------------. 2033| || yyerrlab -- here on detecting error. | 2034| |`--------------------------------------*/ 2035| 818|yyerrlab: 2036| | /* Make sure we have latest lookahead translation. See comments at 2037| | user semantic actions for why this is necessary. */ 2038| 818| yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 818|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 780| 0|#define YYEMPTY (-2) ------------------ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 547| 1.63k| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 818|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 818, False: 0] | | | Branch (547:18): [True: 818, False: 0] | | ------------------ ------------------ | Branch (2038:13): [True: 0, False: 818] ------------------ 2039| | 2040| | /* If not already recovering from an error, report this error. */ 2041| 818| if (!yyerrstatus) ------------------ | Branch (2041:7): [True: 818, False: 0] ------------------ 2042| 818| { 2043| 818| ++yynerrs; ------------------ | | 71| 818|#define yynerrs igraph_dl_yynerrs ------------------ 2044| |#if ! YYERROR_VERBOSE 2045| | yyerror (&yylloc, context, YY_("syntax error")); 2046| |#else 2047| 818|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 2048| 818| yyssp, yytoken) 2049| 818| { 2050| 818| char const *yymsgp = YY_("syntax error"); ------------------ | | 334| 818|# define YY_(Msgid) Msgid ------------------ 2051| 818| int yysyntax_error_status; 2052| 818| yysyntax_error_status = YYSYNTAX_ERROR; ------------------ | | 2047| 818|# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ | | 2048| 818| yyssp, yytoken) ------------------ 2053| 818| if (yysyntax_error_status == 0) ------------------ | Branch (2053:13): [True: 818, False: 0] ------------------ 2054| 818| 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| 818| yyerror (&yylloc, context, yymsgp); ------------------ | | 69| 818|#define yyerror igraph_dl_yyerror ------------------ 2073| 818| if (yysyntax_error_status == 2) ------------------ | Branch (2073:13): [True: 0, False: 818] ------------------ 2074| 0| goto yyexhaustedlab; 2075| 818| } 2076| 818|# undef YYSYNTAX_ERROR 2077| 818|#endif 2078| 818| } 2079| | 2080| 818| yyerror_range[1] = yylloc; 2081| | 2082| 818| if (yyerrstatus == 3) ------------------ | Branch (2082:7): [True: 0, False: 818] ------------------ 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| 818| goto yyerrlab1; 2104| | 2105| | 2106| |/*---------------------------------------------------. 2107| || yyerrorlab -- error raised explicitly by YYERROR. | 2108| |`---------------------------------------------------*/ 2109| 818|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| 818|yyerrlab1: 2128| 818| yyerrstatus = 3; /* Each real token shifted decrements this. */ 2129| | 2130| 818| for (;;) 2131| 7.89k| { 2132| 7.89k| yyn = yypact[yystate]; 2133| 7.89k| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 7.89k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 7.89k|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (2133:11): [True: 6.89k, False: 995] ------------------ 2134| 6.89k| { 2135| 6.89k| yyn += YYTERROR; ------------------ | | 808| 6.89k|#define YYTERROR 1 ------------------ 2136| 6.89k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 529| 13.7k|#define YYLAST 118 ------------------ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) ------------------ | | 808| 6.89k|#define YYTERROR 1 ------------------ | Branch (2136:15): [True: 6.89k, False: 0] | Branch (2136:27): [True: 6.89k, False: 0] | Branch (2136:44): [True: 0, False: 6.89k] ------------------ 2137| 0| { 2138| 0| yyn = yytable[yyn]; 2139| 0| if (0 < yyn) ------------------ | Branch (2139:19): [True: 0, False: 0] ------------------ 2140| 0| break; 2141| 0| } 2142| 6.89k| } 2143| | 2144| | /* Pop the current state because it cannot handle the error token. */ 2145| 7.89k| if (yyssp == yyss) ------------------ | Branch (2145:11): [True: 818, False: 7.07k] ------------------ 2146| 818| YYABORT; ------------------ | | 784| 818|#define YYABORT goto yyabortlab ------------------ 2147| | 2148| 7.07k| yyerror_range[1] = *yylsp; 2149| 7.07k| yydestruct ("Error: popping", 2150| 7.07k| yystos[yystate], yyvsp, yylsp, context); 2151| 7.07k| YYPOPSTACK (1); ------------------ | | 1361| 7.07k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2152| 7.07k| yystate = *yyssp; 2153| 7.07k| YY_STACK_PRINT (yyss, yyssp); 2154| 7.07k| } 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| 813|yyacceptlab: 2177| 813| yyresult = 0; 2178| 813| goto yyreturn; 2179| | 2180| | 2181| |/*-----------------------------------. 2182| || yyabortlab -- YYABORT comes here. | 2183| |`-----------------------------------*/ 2184| 1.49k|yyabortlab: 2185| 1.49k| yyresult = 1; 2186| 1.49k| goto yyreturn; 2187| | 2188| | 2189| 0|#if !defined yyoverflow || YYERROR_VERBOSE 2190| |/*-------------------------------------------------. 2191| || yyexhaustedlab -- memory exhaustion comes here. | 2192| |`-------------------------------------------------*/ 2193| 0|yyexhaustedlab: 2194| 0| yyerror (&yylloc, context, YY_("memory exhausted")); ------------------ | | 69| 0|#define yyerror igraph_dl_yyerror ------------------ yyerror (&yylloc, context, YY_("memory exhausted")); ------------------ | | 334| 0|# define YY_(Msgid) Msgid ------------------ 2195| 0| yyresult = 2; 2196| | /* Fall through. */ 2197| 0|#endif 2198| | 2199| | 2200| |/*-----------------------------------------------------. 2201| || yyreturn -- parsing is finished, return the result. | 2202| |`-----------------------------------------------------*/ 2203| 2.31k|yyreturn: 2204| 2.31k| if (yychar != YYEMPTY) ------------------ | | 780| 2.31k|#define YYEMPTY (-2) ------------------ | Branch (2204:7): [True: 818, False: 1.49k] ------------------ 2205| 818| { 2206| | /* Make sure we have latest lookahead translation. See comments at 2207| | user semantic actions for why this is necessary. */ 2208| 818| yytoken = YYTRANSLATE (yychar); ------------------ | | 547| 818| (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 541| 818|#define YYMAXUTOK 271 | | ------------------ | | (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) | | ------------------ | | | | 540| 0|#define YYUNDEFTOK 2 | | ------------------ | | | Branch (547:4): [True: 818, False: 0] | | | Branch (547:18): [True: 818, False: 0] | | ------------------ ------------------ 2209| 818| yydestruct ("Cleanup: discarding lookahead", 2210| 818| yytoken, &yylval, &yylloc, context); 2211| 818| } 2212| | /* Do not reclaim the symbols of the rule whose action triggered 2213| | this YYABORT or YYACCEPT. */ 2214| 2.31k| YYPOPSTACK (yylen); ------------------ | | 1361| 2.31k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2215| 2.31k| YY_STACK_PRINT (yyss, yyssp); 2216| 9.44k| while (yyssp != yyss) ------------------ | Branch (2216:10): [True: 7.13k, False: 2.31k] ------------------ 2217| 7.13k| { 2218| 7.13k| yydestruct ("Cleanup: popping", 2219| 7.13k| yystos[+*yyssp], yyvsp, yylsp, context); 2220| 7.13k| YYPOPSTACK (1); ------------------ | | 1361| 7.13k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) ------------------ 2221| 7.13k| } 2222| 2.31k|#ifndef yyoverflow 2223| 2.31k| if (yyss != yyssa) ------------------ | Branch (2223:7): [True: 0, False: 2.31k] ------------------ 2224| 0| YYSTACK_FREE (yyss); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2225| 2.31k|#endif 2226| 2.31k|#if YYERROR_VERBOSE 2227| 2.31k| if (yymsg != yymsgbuf) ------------------ | Branch (2227:7): [True: 0, False: 2.31k] ------------------ 2228| 0| YYSTACK_FREE (yymsg); ------------------ | | 435| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 454| 0|# define YYFREE free | | ------------------ ------------------ 2229| 2.31k|#endif 2230| 2.31k| return yyresult; 2231| 0|} igraph_dl_yyerror: 2237| 1.44k| const char *s) { 2238| 1.44k| snprintf(context->errmsg, sizeof(context->errmsg)/sizeof(char)-1, 2239| 1.44k| "Parse error in DL file, line %i (%s)", 2240| 1.44k| locp->first_line, s); 2241| 1.44k| return 0; 2242| 1.44k|} dl-parser.c:yysyntax_error: 1131| 818|{ 1132| 818| enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1133| | /* Internationalized format string. */ 1134| 818| const char *yyformat = YY_NULLPTR; ------------------ | | 138| 818|# define YY_NULLPTR ((void*)0) ------------------ 1135| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1136| | one per "expected"). */ 1137| 818| char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1138| | /* Actual size of YYARG. */ 1139| 818| int yycount = 0; 1140| | /* Cumulated lengths of YYARG. */ 1141| 818| YYPTRDIFF_T yysize = 0; ------------------ | | 285| 818|# 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| 818| if (yytoken != YYEMPTY) ------------------ | | 780| 818|#define YYEMPTY (-2) ------------------ | Branch (1166:7): [True: 818, False: 0] ------------------ 1167| 818| { 1168| 818| int yyn = yypact[+*yyssp]; 1169| 818| YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 285| 818|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); ------------------ | | 138| 818|# define YY_NULLPTR ((void*)0) ------------------ 1170| 818| yysize = yysize0; 1171| 818| yyarg[yycount++] = yytname[yytoken]; 1172| 818| if (!yypact_value_is_default (yyn)) ------------------ | | 632| 818| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 629| 818|#define YYPACT_NINF (-114) | | ------------------ ------------------ | Branch (1172:11): [True: 818, False: 0] ------------------ 1173| 818| { 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| 818| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1177:26): [True: 0, False: 818] ------------------ 1178| | /* Stay within bounds of both yycheck and yytname. */ 1179| 818| int yychecklim = YYLAST - yyn + 1; ------------------ | | 529| 818|#define YYLAST 118 ------------------ 1180| 818| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 818|#define YYNTOKENS 17 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 532| 818|#define YYNTOKENS 17 ------------------ | Branch (1180:24): [True: 0, False: 818] ------------------ 1181| 818| int yyx; 1182| | 1183| 14.6k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1183:32): [True: 13.8k, False: 808] ------------------ 1184| 13.8k| if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR ------------------ | | 808| 15.1k|#define YYTERROR 1 ------------------ | Branch (1184:17): [True: 1.31k, False: 12.5k] | Branch (1184:46): [True: 1.31k, False: 0] ------------------ 1185| 0| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 637| 0| 0 ------------------ | Branch (1185:20): [True: 0, Folded] ------------------ 1186| 1.31k| { 1187| 1.31k| if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ------------------ | Branch (1187:21): [True: 10, False: 1.30k] ------------------ 1188| 10| { 1189| 10| yycount = 1; 1190| 10| yysize = yysize0; 1191| 10| break; 1192| 10| } 1193| 1.30k| yyarg[yycount++] = yytname[yyx]; 1194| 1.30k| { 1195| 1.30k| YYPTRDIFF_T yysize1 ------------------ | | 285| 1.30k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1196| 1.30k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); ------------------ | | 138| 1.30k|# define YY_NULLPTR ((void*)0) ------------------ 1197| 1.30k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 1.30k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 1.30k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 2.61k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 1.30k, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1197:23): [True: 1.30k, False: 0] | Branch (1197:44): [True: 1.30k, False: 0] ------------------ 1198| 1.30k| yysize = yysize1; 1199| 0| else 1200| 0| return 2; 1201| 1.30k| } 1202| 1.30k| } 1203| 818| } 1204| 818| } 1205| | 1206| 818| switch (yycount) 1207| 818| { 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: 818] ------------------ 1213| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1209| 0| case N: \ | | ------------------ | | | Branch (1209:7): [True: 0, False: 818] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1214| 10| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1209| 10| case N: \ | | ------------------ | | | Branch (1209:7): [True: 10, False: 808] | | ------------------ | | 1210| 10| yyformat = S; \ | | 1211| 10| break ------------------ 1215| 374| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1209| 374| case N: \ | | ------------------ | | | Branch (1209:7): [True: 374, False: 444] | | ------------------ | | 1210| 374| yyformat = S; \ | | 1211| 374| break ------------------ 1216| 408| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1209| 408| case N: \ | | ------------------ | | | Branch (1209:7): [True: 408, False: 410] | | ------------------ | | 1210| 408| yyformat = S; \ | | 1211| 408| break ------------------ 1217| 26| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1209| 26| case N: \ | | ------------------ | | | Branch (1209:7): [True: 26, False: 792] | | ------------------ | | 1210| 26| yyformat = S; \ | | 1211| 26| break ------------------ 1218| 818| 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: 818] | | ------------------ | | 1210| 0| yyformat = S; \ | | 1211| 0| break ------------------ 1219| 818|# undef YYCASE_ 1220| 818| } 1221| | 1222| 818| { 1223| | /* Don't count the "%s"s in the final size, but reserve room for 1224| | the terminator. */ 1225| 818| YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 285| 818|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1; ------------------ | | 1035| 818|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 818|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1226| 818| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 437| 818|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 313| 818| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 126| 1.63k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (126:40): [True: 818, Folded] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1226:9): [True: 818, False: 0] | Branch (1226:30): [True: 818, False: 0] ------------------ 1227| 818| yysize = yysize1; 1228| 0| else 1229| 0| return 2; 1230| 818| } 1231| | 1232| 818| if (*yymsg_alloc < yysize) ------------------ | Branch (1232:7): [True: 0, False: 818] ------------------ 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| 818| { 1245| 818| char *yyp = *yymsg; 1246| 818| int yyi = 0; 1247| 34.8k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1247:12): [True: 34.0k, False: 818] ------------------ 1248| 34.0k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1248:11): [True: 2.08k, False: 31.9k] | Branch (1248:26): [True: 2.08k, False: 0] | Branch (1248:48): [True: 2.08k, False: 0] ------------------ 1249| 2.08k| { 1250| 2.08k| yyp += yytnamerr (yyp, yyarg[yyi++]); 1251| 2.08k| yyformat += 2; 1252| 2.08k| } 1253| 31.9k| else 1254| 31.9k| { 1255| 31.9k| ++yyp; 1256| 31.9k| ++yyformat; 1257| 31.9k| } 1258| 818| } 1259| 818| return 0; 1260| 818|} dl-parser.c:yytnamerr: 1079| 4.21k|{ 1080| 4.21k| if (*yystr == '"') ------------------ | Branch (1080:7): [True: 3.03k, False: 1.18k] ------------------ 1081| 3.03k| { 1082| 3.03k| YYPTRDIFF_T yyn = 0; ------------------ | | 285| 3.03k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1083| 3.03k| char const *yyp = yystr; 1084| | 1085| 3.03k| for (;;) 1086| 25.9k| switch (*++yyp) 1087| 25.9k| { 1088| 0| case '\'': ------------------ | Branch (1088:11): [True: 0, False: 25.9k] ------------------ 1089| 0| case ',': ------------------ | Branch (1089:11): [True: 0, False: 25.9k] ------------------ 1090| 0| goto do_not_strip_quotes; 1091| | 1092| 0| case '\\': ------------------ | Branch (1092:11): [True: 0, False: 25.9k] ------------------ 1093| 0| if (*++yyp != '\\') ------------------ | Branch (1093:17): [True: 0, False: 0] ------------------ 1094| 0| goto do_not_strip_quotes; 1095| 0| else 1096| 0| goto append; 1097| | 1098| 0| append: 1099| 22.9k| default: ------------------ | Branch (1099:11): [True: 22.9k, False: 3.03k] ------------------ 1100| 22.9k| if (yyres) ------------------ | Branch (1100:17): [True: 11.3k, False: 11.6k] ------------------ 1101| 11.3k| yyres[yyn] = *yyp; 1102| 22.9k| yyn++; 1103| 22.9k| break; 1104| | 1105| 3.03k| case '"': ------------------ | Branch (1105:11): [True: 3.03k, False: 22.9k] ------------------ 1106| 3.03k| if (yyres) ------------------ | Branch (1106:17): [True: 1.50k, False: 1.53k] ------------------ 1107| 1.50k| yyres[yyn] = '\0'; 1108| 3.03k| return yyn; 1109| 25.9k| } 1110| 0| do_not_strip_quotes: ; 1111| 0| } 1112| | 1113| 1.18k| if (yyres) ------------------ | Branch (1113:7): [True: 585, False: 595] ------------------ 1114| 585| return yystpcpy (yyres, yystr) - yyres; 1115| 595| else 1116| 595| return yystrlen (yystr); ------------------ | | 1035| 595|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 126| 595|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1117| 1.18k|} dl-parser.c:yystpcpy: 1057| 585|{ 1058| 585| char *yyd = yydest; 1059| 585| const char *yys = yysrc; 1060| | 1061| 3.12k| while ((*yyd++ = *yys++) != '\0') ------------------ | Branch (1061:10): [True: 2.54k, False: 585] ------------------ 1062| 2.54k| continue; 1063| | 1064| 585| return yyd - 1; 1065| 585|} dl-parser.c:yydestruct: 1269| 15.0k|{ 1270| 15.0k| YYUSE (yyvaluep); ------------------ | | 356| 15.0k|# define YYUSE(E) ((void) (E)) ------------------ 1271| 15.0k| YYUSE (yylocationp); ------------------ | | 356| 15.0k|# define YYUSE(E) ((void) (E)) ------------------ 1272| 15.0k| YYUSE (context); ------------------ | | 356| 15.0k|# define YYUSE(E) ((void) (E)) ------------------ 1273| 15.0k| if (!yymsg) ------------------ | Branch (1273:7): [True: 0, False: 15.0k] ------------------ 1274| 0| yymsg = "Deleting"; 1275| 15.0k| YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1276| | 1277| 15.0k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1278| 15.0k| YYUSE (yytype); ------------------ | | 356| 15.0k|# define YYUSE(E) ((void) (E)) ------------------ 1279| 15.0k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1280| 15.0k|} dl-parser.c:igraph_i_dl_add_str: 2245| 1.62M| igraph_i_dl_parsedata_t *context) { 2246| 1.62M| IGRAPH_CHECK(igraph_strvector_push_back_len(&context->labels, newstr, length)); ------------------ | | 656| 1.62M| do { \ | | 657| 1.62M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.62M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.62M] | | | | ------------------ | | ------------------ | | 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.62M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.62M] | | ------------------ ------------------ 2247| 1.62M| return IGRAPH_SUCCESS; 2248| 1.62M|} 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: 320, False: 6.21M] ------------------ 2279| 320| IGRAPH_ERRORF("Invalid vertex index in DL file: %" IGRAPH_PRId ".", ------------------ | | 464| 320| do { \ | | 465| 320| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 320| igraph_errno, __VA_ARGS__) ; \ | | 467| 320| return igraph_errno; \ | | 468| 320| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 2280| 320| IGRAPH_EINVAL, dl_vid); 2281| 320| } 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: 244, False: 6.21M] ------------------ 2283| 244| IGRAPH_ERRORF("Vertex index too large in DL file: %" IGRAPH_PRId ".", ------------------ | | 464| 244| do { \ | | 465| 244| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 466| 244| igraph_errno, __VA_ARGS__) ; \ | | 467| 244| return igraph_errno; \ | | 468| 244| } while (0) | | ------------------ | | | Branch (468:14): [Folded, False: 0] | | ------------------ ------------------ 2284| 244| IGRAPH_EINVAL, dl_vid); 2285| 244| } 2286| 6.21M| return IGRAPH_SUCCESS; 2287| 6.21M|} LLVMFuzzerTestOneInput: 25| 2.31k|int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 26| | 27| 2.31k| igraph_set_error_handler(igraph_error_handler_ignore); 28| 2.31k| igraph_set_warning_handler(igraph_warning_handler_ignore); 29| | 30| | // Turn on attribute handling 31| 2.31k| igraph_set_attribute_table(&igraph_cattribute_table); 32| | 33| | // Read input file 34| 2.31k| FILE *ifile = fmemopen((void*) data, size, "r"); 35| 2.31k| if (!ifile) { ------------------ | Branch (35:9): [True: 0, False: 2.31k] ------------------ 36| 0| return 0; 37| 0| } 38| | 39| | // Do the fuzzing 40| 2.31k| igraph_t g; 41| 2.31k| if (igraph_read_graph_dl(&g, ifile, IGRAPH_DIRECTED) == IGRAPH_SUCCESS) { ------------------ | Branch (41:9): [True: 488, False: 1.82k] ------------------ 42| | // Clean up 43| 488| igraph_destroy(&g); 44| 488| } 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.31k| fclose(ifile); 50| | 51| 2.31k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY); ------------------ | | 924| 2.31k| do { \ | | 925| 2.31k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | ------------------ | | | | 401| |# define IGRAPH_FILE_BASENAME __FILE__ | | ------------------ | | 927| 0| } \ | | 928| 2.31k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.31k] | | ------------------ ------------------ 52| | 53| 2.31k| return 0; 54| 2.31k|} igraph_error: 210| 2.96k| igraph_error_t igraph_errno) { 211| | 212| 2.96k| if (igraph_i_error_handler) { ------------------ | Branch (212:9): [True: 2.96k, False: 0] ------------------ 213| 2.96k| igraph_i_error_handler(reason, file, line, igraph_errno); 214| 2.96k|#ifndef USING_R 215| 2.96k| } else { 216| 0| igraph_error_handler_abort(reason, file, line, igraph_errno); 217| 0|#endif 218| 0| } 219| 2.96k| return igraph_errno; 220| 2.96k|} igraph_errorf: 240| 617| igraph_error_t igraph_errno, ...) { 241| 617| va_list ap; 242| 617| va_start(ap, igraph_errno); 243| 617| vsnprintf(igraph_i_errormsg_buffer, 244| 617| sizeof(igraph_i_errormsg_buffer) / sizeof(char), reason, ap); 245| | va_end(ap); 246| 617| return igraph_error(igraph_i_errormsg_buffer, file, line, igraph_errno); 247| 617|} igraph_error_handler_ignore: 266| 2.96k| int line, igraph_error_t igraph_errno) { 267| 2.96k| IGRAPH_UNUSED(reason); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 268| 2.96k| IGRAPH_UNUSED(file); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 269| 2.96k| IGRAPH_UNUSED(line); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 270| 2.96k| IGRAPH_UNUSED(igraph_errno); ------------------ | | 30| 2.96k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 271| | 272| 2.96k| IGRAPH_FINALLY_FREE(); 273| 2.96k|} igraph_set_error_handler: 298| 2.31k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) { 299| 2.31k| igraph_error_handler_t *previous_handler = igraph_i_error_handler; 300| 2.31k| igraph_i_error_handler = new_handler; 301| 2.31k| return previous_handler; 302| 2.31k|} IGRAPH_FINALLY_REAL: 320| 86.1k|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) { 321| 86.1k| int no = igraph_i_finally_stack_size; 322| 86.1k| if (no < 0) { ------------------ | Branch (322:9): [True: 0, False: 86.1k] ------------------ 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| 86.1k| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) { ------------------ | Branch (327:9): [True: 0, False: 86.1k] ------------------ 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| 86.1k| igraph_i_finally_stack[no].ptr = ptr; 333| 86.1k| igraph_i_finally_stack[no].func = func; 334| 86.1k| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level; 335| 86.1k| igraph_i_finally_stack_size++; 336| 86.1k|} IGRAPH_FINALLY_CLEAN: 338| 27.5k|void IGRAPH_FINALLY_CLEAN(int minus) { 339| 27.5k| igraph_i_finally_stack_size -= minus; 340| 27.5k| if (igraph_i_finally_stack_size < 0) { ------------------ | Branch (340:9): [True: 0, False: 27.5k] ------------------ 341| 0| int left = igraph_i_finally_stack_size + minus; 342| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 343| 0| igraph_i_reset_finally_stack(); 344| 0| IGRAPH_FATALF("Corrupt finally stack: trying to pop %d element(s) when only %d left.", minus, left); ------------------ | | 875| 0| do { \ | | 876| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 877| 0| __VA_ARGS__); \ | | 878| 0| } while (0) | | ------------------ | | | Branch (878:14): [Folded, False: 0] | | ------------------ ------------------ 345| 0| } 346| 27.5k|} IGRAPH_FINALLY_FREE: 348| 2.96k|void IGRAPH_FINALLY_FREE(void) { 349| 12.6k| for (; igraph_i_finally_stack_size > 0; igraph_i_finally_stack_size--) { ------------------ | Branch (349:12): [True: 10.4k, False: 2.14k] ------------------ 350| 10.4k| int p = igraph_i_finally_stack_size - 1; 351| | /* Call destructors only up to the current level */ 352| 10.4k| if (igraph_i_finally_stack[p].level < igraph_i_finally_stack_level) { ------------------ | Branch (352:13): [True: 813, False: 9.68k] ------------------ 353| 813| break; 354| 813| } 355| 9.68k| igraph_i_finally_stack[p].func(igraph_i_finally_stack[p].ptr); 356| 9.68k| } 357| 2.96k|} IGRAPH_FINALLY_STACK_SIZE: 359| 2.31k|int IGRAPH_FINALLY_STACK_SIZE(void) { 360| 2.31k| return igraph_i_finally_stack_size; 361| 2.31k|} IGRAPH_FINALLY_ENTER: 377| 555k|void IGRAPH_FINALLY_ENTER(void) { 378| 555k| int no = igraph_i_finally_stack_size; 379| | /* Level indices must always be in increasing order in the finally stack */ 380| 555k| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) { ------------------ | Branch (380:9): [True: 555k, False: 0] | Branch (380:19): [True: 0, False: 555k] ------------------ 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| 555k| igraph_i_finally_stack_level++; 386| 555k|} IGRAPH_FINALLY_EXIT: 399| 555k|void IGRAPH_FINALLY_EXIT(void) { 400| 555k| igraph_i_finally_stack_level--; 401| 555k| if (igraph_i_finally_stack_level < 0) { ------------------ | Branch (401:9): [True: 0, False: 555k] ------------------ 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| 555k|} igraph_warning_handler_ignore: 424| 293|void igraph_warning_handler_ignore(const char *reason, const char *file, int line) { 425| 293| IGRAPH_UNUSED(reason); ------------------ | | 30| 293|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 426| 293| IGRAPH_UNUSED(file); ------------------ | | 30| 293|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 427| 293| IGRAPH_UNUSED(line); ------------------ | | 30| 293|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 428| 293|} igraph_warning: 463| 293|void igraph_warning(const char *reason, const char *file, int line) { 464| | 465| 293| if (igraph_i_warning_handler) { ------------------ | Branch (465:9): [True: 293, False: 0] ------------------ 466| 293| igraph_i_warning_handler(reason, file, line); 467| 293|#ifndef USING_R 468| 293| } else { 469| 0| igraph_warning_handler_print(reason, file, line); 470| 0|#endif 471| 0| } 472| 293|} igraph_set_warning_handler: 514| 2.31k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) { 515| 2.31k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler; 516| 2.31k| igraph_i_warning_handler = new_handler; 517| 2.31k| return previous_handler; 518| 2.31k|} igraph_free: 62| 1.47k|void igraph_free(void *ptr) { 63| | IGRAPH_FREE(ptr); ------------------ | | 36| 1.47k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 64| 1.47k|} igraph_strvector_init: 71| 15.6k|igraph_error_t igraph_strvector_init(igraph_strvector_t *sv, igraph_int_t size) { 72| | 73| 15.6k| sv->stor_begin = IGRAPH_CALLOC(size, const char *); ------------------ | | 33| 15.6k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 31.2k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 15.6k, False: 0] | | | | | Branch (31:24): [True: 15.6k, False: 0] | | | | | Branch (31:66): [True: 8.33k, False: 7.27k] | | | | ------------------ | | ------------------ ------------------ 74| 15.6k| IGRAPH_CHECK_OOM(sv->stor_begin, "Cannot initialize string vector."); ------------------ | | 709| 15.6k| do { \ | | 710| 15.6k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 15.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| 15.6k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 15.6k] | | ------------------ ------------------ 75| | 76| 15.6k| sv->stor_end = sv->stor_begin + size; 77| 15.6k| sv->end = sv->stor_end; 78| | 79| 15.6k| return IGRAPH_SUCCESS; 80| 15.6k|} igraph_strvector_destroy: 95| 15.6k|void igraph_strvector_destroy(igraph_strvector_t *sv) { 96| 15.6k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 15.6k| do { \ | | 925| 15.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 15.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 15.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 15.6k] | | ------------------ ------------------ 97| 15.6k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 15.6k| do { \ | | 925| 15.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 15.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 15.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 15.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 15.6k] | | ------------------ ------------------ 98| 2.19M| for (const char **ptr = sv->stor_begin; ptr < sv->end; ptr++) { ------------------ | Branch (98:45): [True: 2.18M, False: 15.6k] ------------------ 99| 2.18M| IGRAPH_FREE(*ptr); ------------------ | | 36| 2.18M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 100| 2.18M| } 101| | IGRAPH_FREE(sv->stor_begin); ------------------ | | 36| 15.6k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 102| 15.6k|} igraph_strvector_get: 117| 7.40M|const char *igraph_strvector_get(const igraph_strvector_t *sv, igraph_int_t idx) { 118| 7.40M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 7.40M| do { \ | | 925| 7.40M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 7.40M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.40M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 7.40M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 7.40M] | | ------------------ ------------------ 119| 7.40M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 7.40M| do { \ | | 925| 7.40M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 7.40M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.40M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 7.40M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 7.40M] | | ------------------ ------------------ 120| 7.40M| return sv->stor_begin[idx] ? sv->stor_begin[idx] : ""; ------------------ | Branch (120:12): [True: 7.40M, False: 0] ------------------ 121| 7.40M|} igraph_strvector_set: 141| 19.1k| const char *value) { 142| 19.1k| return igraph_strvector_set_len(sv, idx, value, strlen(value)); 143| 19.1k|} igraph_strvector_set_len: 163| 19.1k| const char *value, size_t len) { 164| 19.1k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 19.1k| do { \ | | 925| 19.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 19.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 19.1k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 19.1k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 19.1k] | | ------------------ ------------------ 165| 19.1k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 19.1k| do { \ | | 925| 19.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 19.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 19.1k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 19.1k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 19.1k] | | ------------------ ------------------ 166| | 167| 19.1k| if (sv->stor_begin[idx] == NULL) { ------------------ | Branch (167:9): [True: 12.1k, False: 6.98k] ------------------ 168| 12.1k| sv->stor_begin[idx] = strndup(value, len); 169| 12.1k| IGRAPH_CHECK_OOM(sv->stor_begin[idx], "Cannot reserve space for new item in string vector."); ------------------ | | 709| 12.1k| do { \ | | 710| 12.1k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 12.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 12.1k] | | | | ------------------ | | ------------------ | | 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.1k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 12.1k] | | ------------------ ------------------ 170| 12.1k| } else { 171| 6.98k| char *tmp = IGRAPH_REALLOC(sv->stor_begin[idx], len + 1, char); ------------------ | | 35| 6.98k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 13.9k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 6.98k, False: 0] | | | | | Branch (31:24): [True: 6.98k, False: 0] | | | | | Branch (31:66): [True: 6.98k, False: 0] | | | | ------------------ | | ------------------ ------------------ 172| 6.98k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new item in string vector."); ------------------ | | 709| 6.98k| do { \ | | 710| 6.98k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 6.98k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 6.98k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 6.98k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 6.98k] | | ------------------ ------------------ 173| | 174| 6.98k| memcpy(tmp, value, len * sizeof(char)); 175| 6.98k| tmp[len] = '\0'; 176| 6.98k| sv->stor_begin[idx] = tmp; 177| 6.98k| } 178| | 179| 19.1k| return IGRAPH_SUCCESS; 180| 19.1k|} igraph_strvector_append: 300| 205| const igraph_strvector_t *from) { 301| 205| const igraph_int_t to_size = igraph_strvector_size(to); 302| 205| const igraph_int_t from_size = igraph_strvector_size(from); 303| 205| const igraph_int_t to_capacity = igraph_strvector_capacity(to); 304| 205| igraph_int_t new_to_size; 305| 205| igraph_bool_t error = false; 306| 205| const char *tmp; 307| | 308| 205| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 205| do { \ | | 48| 205| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 205| igraph_int_t _safe_sum; \ | | 50| 205| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 205] | | ------------------ | | 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| 205| *(res) = _safe_sum; \ | | 54| 205| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 205] | | ------------------ ------------------ 309| | 310| 205| if (to_capacity < new_to_size) { ------------------ | Branch (310:9): [True: 205, False: 0] ------------------ 311| 205| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 205|# 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| 205|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (311:40): [True: 205, False: 0] ------------------ 312| 205| if (new_to_capacity < new_to_size) { ------------------ | Branch (312:13): [True: 205, False: 0] ------------------ 313| 205| new_to_capacity = new_to_size; 314| 205| } 315| 205| IGRAPH_CHECK(igraph_strvector_reserve(to, new_to_capacity)); ------------------ | | 656| 205| do { \ | | 657| 205| igraph_error_t igraph_i_ret = (expr); \ | | 658| 205| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 205| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 205] | | | | ------------------ | | ------------------ | | 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| 205| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 205] | | ------------------ ------------------ 316| 205| } 317| | 318| 1.05M| for (igraph_int_t i = 0; i < from_size; i++) { ------------------ | Branch (318:30): [True: 1.05M, False: 205] ------------------ 319| 1.05M| if (from->stor_begin[i] == NULL || from->stor_begin[i][0] == '\0') { ------------------ | Branch (319:13): [True: 0, False: 1.05M] | Branch (319:44): [True: 0, False: 1.05M] ------------------ 320| | /* Represent empty strings as NULL. */ 321| 0| tmp = NULL; 322| 1.05M| } else { 323| 1.05M| tmp = strdup(from->stor_begin[i]); 324| 1.05M| if (tmp == NULL) { ------------------ | Branch (324:17): [True: 0, False: 1.05M] ------------------ 325| 0| error = true; 326| 0| break; 327| 0| } 328| 1.05M| } 329| 1.05M| *(to->end) = tmp; 330| 1.05M| to->end++; 331| 1.05M| } 332| | 333| 205| if (error) { ------------------ | Branch (333:9): [True: 0, False: 205] ------------------ 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| 205| return IGRAPH_SUCCESS; 339| 205|} igraph_strvector_clear: 393| 317|void igraph_strvector_clear(igraph_strvector_t *sv) { 394| 317| igraph_int_t n = igraph_strvector_size(sv); 395| | 396| 542k| for (igraph_int_t i = 0; i < n; i++) { ------------------ | Branch (396:30): [True: 541k, False: 317] ------------------ 397| | IGRAPH_FREE(sv->stor_begin[i]); ------------------ | | 36| 541k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 398| 541k| } 399| 317| sv->end = sv->stor_begin; 400| 317|} 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: 133] ------------------ 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: 133] ------------------ 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.38k|igraph_int_t igraph_strvector_capacity(const igraph_strvector_t *sv) { 449| 8.38k| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 8.38k| do { \ | | 925| 8.38k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 8.38k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.38k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.38k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.38k] | | ------------------ ------------------ 450| 8.38k| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 8.38k| do { \ | | 925| 8.38k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 8.38k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.38k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 8.38k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 8.38k] | | ------------------ ------------------ 451| 8.38k| return sv->stor_end - sv->stor_begin; 452| 8.38k|} igraph_strvector_reserve: 481| 8.18k|igraph_error_t igraph_strvector_reserve(igraph_strvector_t *sv, igraph_int_t capacity) { 482| 8.18k| igraph_int_t current_capacity = igraph_strvector_capacity(sv); 483| | 484| 8.18k| if (capacity <= current_capacity) { ------------------ | Branch (484:9): [True: 0, False: 8.18k] ------------------ 485| 0| return IGRAPH_SUCCESS; 486| 0| } 487| | 488| 8.18k| const char **tmp = IGRAPH_REALLOC(sv->stor_begin, capacity, const char *); ------------------ | | 35| 8.18k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 16.3k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 8.18k, False: 0] | | | | | Branch (31:24): [True: 8.18k, False: 0] | | | | | Branch (31:66): [True: 8.18k, False: 0] | | | | ------------------ | | ------------------ ------------------ 489| 8.18k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for new items in string vector."); ------------------ | | 709| 8.18k| do { \ | | 710| 8.18k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 8.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.18k] | | | | ------------------ | | ------------------ | | 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.18k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 8.18k] | | ------------------ ------------------ 490| | 491| 8.18k| sv->end = tmp + (sv->end - sv->stor_begin); 492| 8.18k| sv->stor_begin = tmp; 493| 8.18k| sv->stor_end = sv->stor_begin + capacity; 494| | 495| 8.18k| return IGRAPH_SUCCESS; 496| 8.18k|} igraph_strvector_size: 538| 2.12M|igraph_int_t igraph_strvector_size(const igraph_strvector_t *sv) { 539| 2.12M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 2.12M| do { \ | | 925| 2.12M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.12M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.12M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.12M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.12M] | | ------------------ ------------------ 540| 2.12M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 2.12M| do { \ | | 925| 2.12M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.12M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.12M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.12M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.12M] | | ------------------ ------------------ 541| 2.12M| return sv->end - sv->stor_begin; 542| 2.12M|} igraph_strvector_push_back: 580| 562k|igraph_error_t igraph_strvector_push_back(igraph_strvector_t *sv, const char *value) { 581| 562k| IGRAPH_CHECK(strvector_expand_if_full(sv)); ------------------ | | 656| 562k| do { \ | | 657| 562k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 562k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 562k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 562k] | | | | ------------------ | | ------------------ | | 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| 562k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 562k] | | ------------------ ------------------ 582| 562k| const char *tmp = strdup(value); 583| 562k| IGRAPH_CHECK_OOM(tmp, "Cannot push new string to string vector."); ------------------ | | 709| 562k| do { \ | | 710| 562k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 562k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 562k] | | | | ------------------ | | ------------------ | | 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| 562k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 562k] | | ------------------ ------------------ 584| 562k| *sv->end = tmp; 585| 562k| sv->end++; 586| | 587| 562k| return IGRAPH_SUCCESS; 588| 562k|} igraph_strvector_push_back_len: 606| 1.62M| const char *value, size_t len) { 607| | 608| 1.62M| IGRAPH_CHECK(strvector_expand_if_full(sv)); ------------------ | | 656| 1.62M| do { \ | | 657| 1.62M| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.62M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.62M] | | | | ------------------ | | ------------------ | | 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.62M| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.62M] | | ------------------ ------------------ 609| 1.62M| const char *tmp = strndup(value, len); 610| 1.62M| IGRAPH_CHECK_OOM(tmp, "Insufficient memory to push to string vector."); ------------------ | | 709| 1.62M| do { \ | | 710| 1.62M| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.62M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.62M] | | | | ------------------ | | ------------------ | | 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.62M| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.62M] | | ------------------ ------------------ 611| 1.62M| *sv->end = tmp; 612| 1.62M| sv->end++; 613| | 614| 1.62M| return IGRAPH_SUCCESS; 615| 1.62M|} igraph_strvector_update: 698| 169|) { 699| 169| igraph_strvector_clear(to); 700| 169| IGRAPH_CHECK(igraph_strvector_append(to, from)); ------------------ | | 656| 169| do { \ | | 657| 169| igraph_error_t igraph_i_ret = (expr); \ | | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 169] | | | | ------------------ | | ------------------ | | 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| 169| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 169] | | ------------------ ------------------ 701| 169| return IGRAPH_SUCCESS; 702| 169|} strvector.c:strvector_expand_if_full: 548| 2.18M|static igraph_error_t strvector_expand_if_full(igraph_strvector_t *sv) { 549| 2.18M| IGRAPH_ASSERT(sv != NULL); ------------------ | | 924| 2.18M| do { \ | | 925| 2.18M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.18M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.18M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.18M] | | ------------------ ------------------ 550| 2.18M| IGRAPH_ASSERT(sv->stor_begin != NULL); ------------------ | | 924| 2.18M| do { \ | | 925| 2.18M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.18M] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.18M| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.18M] | | ------------------ ------------------ 551| | 552| 2.18M| if (sv->stor_end == sv->end) { ------------------ | Branch (552:9): [True: 7.97k, False: 2.17M] ------------------ 553| 7.97k| igraph_int_t old_size = igraph_strvector_size(sv); 554| 7.97k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.97k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.97k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (554:33): [True: 7.97k, False: 0] ------------------ 555| 7.97k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 7.97k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (555:13): [True: 0, False: 7.97k] ------------------ 556| 0| IGRAPH_ERROR("Cannot add new item to string vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 557| 0| } 558| 7.97k| if (new_size == 0) { ------------------ | Branch (558:13): [True: 1.01k, False: 6.95k] ------------------ 559| 1.01k| new_size = 1; 560| 1.01k| } 561| 7.97k| IGRAPH_CHECK(igraph_strvector_reserve(sv, new_size)); ------------------ | | 656| 7.97k| do { \ | | 657| 7.97k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 7.97k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 7.97k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.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| 7.97k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 7.97k] | | ------------------ ------------------ 562| 7.97k| } 563| | 564| 2.18M| return IGRAPH_SUCCESS; 565| 2.18M|} igraph_trie_init: 61| 2.31k|igraph_error_t igraph_trie_init(igraph_trie_t *t, igraph_bool_t storekeys) { 62| 2.31k| t->maxvalue = -1; 63| 2.31k| t->storekeys = storekeys; 64| 2.31k| IGRAPH_CHECK(igraph_i_trie_init_node(&t->node)); ------------------ | | 656| 2.31k| do { \ | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | ------------------ | | ------------------ | | 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.31k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.31k] | | ------------------ ------------------ 65| 2.31k| IGRAPH_FINALLY(igraph_i_trie_destroy_node, &t->node); ------------------ | | 603| 2.31k| do { \ | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | 607| 2.31k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.31k] | | ------------------ | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.31k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.31k] | | ------------------ ------------------ 66| 2.31k| if (storekeys) { ------------------ | Branch (66:9): [True: 2.31k, False: 0] ------------------ 67| 2.31k| IGRAPH_CHECK(igraph_strvector_init(&t->keys, 0)); ------------------ | | 656| 2.31k| do { \ | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | ------------------ | | ------------------ | | 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.31k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.31k] | | ------------------ ------------------ 68| 2.31k| } 69| | 70| 2.31k| IGRAPH_FINALLY_CLEAN(1); 71| 2.31k| return IGRAPH_SUCCESS; 72| 2.31k|} igraph_trie_destroy: 102| 2.31k|void igraph_trie_destroy(igraph_trie_t *t) { 103| 2.31k| if (t->storekeys) { ------------------ | Branch (103:9): [True: 2.31k, False: 0] ------------------ 104| 2.31k| igraph_strvector_destroy(&t->keys); 105| 2.31k| } 106| 2.31k| igraph_i_trie_destroy_node(&t->node); 107| 2.31k|} igraph_trie_get: 298| 550k|igraph_error_t igraph_trie_get(igraph_trie_t *t, const char *key, igraph_int_t *id) { 299| 550k| assert(key != NULL); ------------------ | Branch (299:5): [True: 0, False: 550k] | Branch (299:5): [True: 550k, False: 0] ------------------ 300| | 301| 550k| if (*key == '\0') { ------------------ | Branch (301:9): [True: 0, False: 550k] ------------------ 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| 550k| if (!t->storekeys) { ------------------ | Branch (305:9): [True: 0, False: 550k] ------------------ 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| 550k| } else { 311| 550k| igraph_error_t ret; 312| | 313| 550k| IGRAPH_FINALLY_ENTER(); 314| | /* Add it to the string vector first, we can undo this later */ 315| 550k| ret = igraph_strvector_push_back(&t->keys, key); 316| 550k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (316:13): [True: 0, False: 550k] ------------------ 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| 550k| ret = igraph_i_trie_get_node(&t->node, key, t->maxvalue + 1, id); 321| 550k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (321:13): [True: 0, False: 550k] ------------------ 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| 550k| if (*id > t->maxvalue) { ------------------ | Branch (328:13): [True: 20.5k, False: 530k] ------------------ 329| 20.5k| 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| 550k| IGRAPH_FINALLY_EXIT(); 334| 550k| } 335| | 336| 550k| return IGRAPH_SUCCESS; 337| 550k|} igraph_trie_get_len: 357| 8.87k| igraph_int_t *id) { 358| | 359| 8.87k| char *tmp = strndup(key, length); 360| 8.87k| IGRAPH_CHECK_OOM(tmp, "Cannot get from trie."); ------------------ | | 709| 8.87k| do { \ | | 710| 8.87k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 8.87k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.87k] | | | | ------------------ | | ------------------ | | 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.87k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 8.87k] | | ------------------ ------------------ 361| 8.87k| IGRAPH_FINALLY(igraph_free, tmp); ------------------ | | 603| 8.87k| do { \ | | 604| 8.87k| /* the following branch makes the compiler check the compatibility of \ | | 605| 8.87k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 8.87k| * incorrect destructor function with the pointer */ \ | | 607| 8.87k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 8.87k] | | ------------------ | | 608| 8.87k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 8.87k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 8.87k] | | ------------------ ------------------ 362| 8.87k| IGRAPH_CHECK(igraph_trie_get(t, tmp, id)); ------------------ | | 656| 8.87k| do { \ | | 657| 8.87k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 8.87k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 8.87k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 8.87k] | | | | ------------------ | | ------------------ | | 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.87k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 8.87k] | | ------------------ ------------------ 363| 8.87k| IGRAPH_FREE(tmp); ------------------ | | 36| 8.87k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 364| 8.87k| IGRAPH_FINALLY_CLEAN(1); 365| | 366| 8.87k| return IGRAPH_SUCCESS; 367| 8.87k|} igraph_trie_size: 413| 719|igraph_int_t igraph_trie_size(igraph_trie_t *t) { 414| 719| return t->maxvalue + 1; 415| 719|} igraph_i_trie_borrow_keys: 432| 75|const igraph_strvector_t* igraph_i_trie_borrow_keys(igraph_trie_t *t) { 433| 75| return &t->keys; 434| 75|} trie.c:igraph_i_trie_init_node: 41| 2.31k|static igraph_error_t igraph_i_trie_init_node(igraph_trie_node_t *t) { 42| 2.31k| IGRAPH_STRVECTOR_INIT_FINALLY(&t->strs, 0); ------------------ | | 62| 2.31k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 2.31k| do { \ | | | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 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.31k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | 63| 2.31k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 2.31k| do { \ | | | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.31k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.31k] | | | | ------------------ | | | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 2.31k] | | ------------------ ------------------ 43| 2.31k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&t->children, 0); ------------------ | | 46| 2.31k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 2.31k| do { \ | | | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 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.31k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | 47| 2.31k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 2.31k| do { \ | | | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.31k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.31k] | | | | ------------------ | | | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 2.31k] | | ------------------ ------------------ 44| 2.31k| IGRAPH_VECTOR_INT_INIT_FINALLY(&t->values, 0); ------------------ | | 119| 2.31k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 2.31k| do { \ | | | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 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.31k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | 120| 2.31k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 2.31k| do { \ | | | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.31k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.31k] | | | | ------------------ | | | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 2.31k] | | ------------------ ------------------ 45| 2.31k| IGRAPH_FINALLY_CLEAN(3); 46| 2.31k| return IGRAPH_SUCCESS; 47| 2.31k|} trie.c:igraph_i_trie_destroy_node: 91| 2.31k|static void igraph_i_trie_destroy_node(igraph_trie_node_t *t) { 92| | igraph_i_trie_destroy_node_helper(t, false); 93| 2.31k|} trie.c:igraph_i_trie_destroy_node_helper: 74| 10.6k|static void igraph_i_trie_destroy_node_helper(igraph_trie_node_t *t, igraph_bool_t sfree) { 75| 10.6k| igraph_strvector_destroy(&t->strs); 76| 10.6k| igraph_int_t children_size = igraph_vector_ptr_size(&t->children); 77| 34.2k| for (igraph_int_t i = 0; i < children_size; i++) { ------------------ | Branch (77:30): [True: 23.6k, False: 10.6k] ------------------ 78| 23.6k| igraph_trie_node_t *child = VECTOR(t->children)[i]; ------------------ | | 60| 23.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 79| 23.6k| if (child != NULL) { ------------------ | Branch (79:13): [True: 8.33k, False: 15.3k] ------------------ 80| 8.33k| igraph_i_trie_destroy_node_helper(child, true); 81| 8.33k| } 82| 23.6k| } 83| 10.6k| igraph_vector_ptr_destroy(&t->children); 84| 10.6k| igraph_vector_int_destroy(&t->values); 85| 10.6k| if (sfree) { ------------------ | Branch (85:9): [True: 8.33k, False: 2.31k] ------------------ 86| | IGRAPH_FREE(t); ------------------ | | 36| 8.33k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 87| 8.33k| } 88| 10.6k|} 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.87M| for (igraph_int_t i = 0; i < strs_size; i++) { ------------------ | Branch (137:30): [True: 6.86M, False: 11.4k] ------------------ 138| 6.86M| size_t diff; 139| 6.86M| const char *str = igraph_strvector_get(&t->strs, i); 140| 6.86M| diff = igraph_i_strdiff(str, key); 141| | 142| 6.86M| if (diff == 0) { ------------------ | Branch (142:13): [True: 5.82M, False: 1.03M] ------------------ 143| | 144| | /* ------------------------------------ */ 145| | /* No match, next */ 146| | 147| 5.82M| } else if (str[diff] == '\0' && key[diff] == '\0') { ------------------ | Branch (147:20): [True: 1.03M, False: 6.98k] | Branch (147:41): [True: 530k, False: 500k] ------------------ 148| | 149| | /* ------------------------------------ */ 150| | /* They are exactly the same */ 151| 530k| if (VECTOR(t->values)[i] != -1) { ------------------ | | 60| 530k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (151:17): [True: 530k, False: 704] ------------------ 152| 530k| *id = VECTOR(t->values)[i]; ------------------ | | 60| 530k|#define VECTOR(v) ((v).stor_begin) ------------------ 153| 530k| return IGRAPH_SUCCESS; 154| 530k| } else { 155| 704| VECTOR(t->values)[i] = newvalue; ------------------ | | 60| 704|#define VECTOR(v) ((v).stor_begin) ------------------ 156| 704| *id = newvalue; 157| 704| return IGRAPH_SUCCESS; 158| 704| } 159| | 160| 530k| } else if (str[diff] == '\0') { ------------------ | Branch (160:20): [True: 500k, False: 6.98k] ------------------ 161| | 162| | /* ------------------------------------ */ 163| | /* str is prefix of key, follow its link if there is one */ 164| 500k| igraph_trie_node_t *node = VECTOR(t->children)[i]; ------------------ | | 60| 500k|#define VECTOR(v) ((v).stor_begin) ------------------ 165| 500k| if (node != NULL) { ------------------ | Branch (165:17): [True: 499k, False: 1.35k] ------------------ 166| 499k| return igraph_i_trie_get_node(node, key + diff, newvalue, id); 167| 499k| } else if (add) { ------------------ | Branch (167:24): [True: 1.35k, False: 0] ------------------ 168| 1.35k| igraph_trie_node_t *new_node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 1.35k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 2.70k| (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.35k, Folded] | | | | ------------------ | | ------------------ ------------------ 169| 1.35k| IGRAPH_CHECK_OOM(new_node, "Cannot add to trie."); ------------------ | | 709| 1.35k| do { \ | | 710| 1.35k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.35k] | | | | ------------------ | | ------------------ | | 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.35k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.35k] | | ------------------ ------------------ 170| 1.35k| IGRAPH_FINALLY(igraph_free, new_node); ------------------ | | 603| 1.35k| do { \ | | 604| 1.35k| /* the following branch makes the compiler check the compatibility of \ | | 605| 1.35k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 1.35k| * incorrect destructor function with the pointer */ \ | | 607| 1.35k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 1.35k] | | ------------------ | | 608| 1.35k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 1.35k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 1.35k] | | ------------------ ------------------ 171| | 172| 1.35k| IGRAPH_STRVECTOR_INIT_FINALLY(&new_node->strs, 1); ------------------ | | 62| 1.35k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 1.35k| do { \ | | | | 657| 1.35k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.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| 1.35k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.35k] | | | | ------------------ | | ------------------ | | 63| 1.35k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 1.35k| do { \ | | | | 604| 1.35k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.35k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.35k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.35k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.35k] | | | | ------------------ | | | | 608| 1.35k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.35k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.35k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 1.35k] | | ------------------ ------------------ 173| 1.35k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&new_node->children, 1); ------------------ | | 46| 1.35k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 1.35k| do { \ | | | | 657| 1.35k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.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| 1.35k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.35k] | | | | ------------------ | | ------------------ | | 47| 1.35k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 1.35k| do { \ | | | | 604| 1.35k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.35k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.35k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.35k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.35k] | | | | ------------------ | | | | 608| 1.35k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.35k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.35k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 1.35k] | | ------------------ ------------------ 174| 1.35k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_node->values, 1); ------------------ | | 119| 1.35k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 1.35k| do { \ | | | | 657| 1.35k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 1.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 1.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 1.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| 1.35k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 1.35k] | | | | ------------------ | | ------------------ | | 120| 1.35k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 1.35k| do { \ | | | | 604| 1.35k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 1.35k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 1.35k| * incorrect destructor function with the pointer */ \ | | | | 607| 1.35k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 1.35k] | | | | ------------------ | | | | 608| 1.35k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 1.35k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 1.35k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 1.35k] | | ------------------ ------------------ 175| 1.35k| IGRAPH_CHECK(igraph_strvector_set(&new_node->strs, 0, key + diff)); ------------------ | | 656| 1.35k| do { \ | | 657| 1.35k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.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| 1.35k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.35k] | | ------------------ ------------------ 176| 1.35k| IGRAPH_FINALLY_CLEAN(4); 177| | 178| 1.35k| VECTOR(new_node->children)[0] = 0; ------------------ | | 60| 1.35k|#define VECTOR(v) ((v).stor_begin) ------------------ 179| 1.35k| VECTOR(new_node->values)[0] = newvalue; ------------------ | | 60| 1.35k|#define VECTOR(v) ((v).stor_begin) ------------------ 180| | 181| 1.35k| VECTOR(t->children)[i] = new_node; ------------------ | | 60| 1.35k|#define VECTOR(v) ((v).stor_begin) ------------------ 182| | 183| 1.35k| *id = newvalue; 184| 1.35k| return IGRAPH_SUCCESS; 185| 1.35k| } else { 186| 0| *id = -1; 187| 0| return IGRAPH_SUCCESS; 188| 0| } 189| | 190| 500k| } else if (key[diff] == '\0' && add) { ------------------ | Branch (190:20): [True: 3.16k, False: 3.81k] | Branch (190:41): [True: 3.16k, False: 0] ------------------ 191| | 192| | /* ------------------------------------ */ 193| | /* key is prefix of str, the node has to be cut */ 194| 3.16k| char *str2; 195| | 196| 3.16k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 3.16k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 6.32k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 0, Folded] | | | | | Branch (31:24): [True: 0, Folded] | | | | | Branch (31:66): [True: 3.16k, Folded] | | | | ------------------ | | ------------------ ------------------ 197| 3.16k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 709| 3.16k| do { \ | | 710| 3.16k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 3.16k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.16k] | | ------------------ ------------------ 198| 3.16k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 603| 3.16k| do { \ | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | 607| 3.16k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.16k] | | ------------------ | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.16k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.16k] | | ------------------ ------------------ 199| | 200| 3.16k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 1); ------------------ | | 62| 3.16k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 3.16k| do { \ | | | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | 63| 3.16k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 3.16k| do { \ | | | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.16k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.16k] | | | | ------------------ | | | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 3.16k] | | ------------------ ------------------ 201| 3.16k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 1); ------------------ | | 46| 3.16k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 3.16k| do { \ | | | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | 47| 3.16k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 3.16k| do { \ | | | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.16k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.16k] | | | | ------------------ | | | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 3.16k] | | ------------------ ------------------ 202| 3.16k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 1); ------------------ | | 119| 3.16k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 3.16k| do { \ | | | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | | | ------------------ | | | | ------------------ | | | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 426| 0| do { \ | | | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 428| 0| return igraph_errno ; \ | | | | | | 429| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (429:14): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 660| 0| } \ | | | | 661| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | 120| 3.16k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 3.16k| do { \ | | | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.16k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.16k] | | | | ------------------ | | | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.16k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.16k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 3.16k] | | ------------------ ------------------ 203| 3.16k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 656| 3.16k| do { \ | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.16k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.16k] | | ------------------ ------------------ 204| | 205| 3.16k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 206| 3.16k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 207| | 208| 3.16k| str2 = strdup(str); 209| 3.16k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 709| 3.16k| do { \ | | 710| 3.16k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 3.16k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.16k] | | ------------------ ------------------ 210| 3.16k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 603| 3.16k| do { \ | | 604| 3.16k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.16k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.16k| * incorrect destructor function with the pointer */ \ | | 607| 3.16k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.16k] | | ------------------ | | 608| 3.16k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.16k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.16k] | | ------------------ ------------------ 211| 3.16k| str2[diff] = '\0'; 212| | 213| 3.16k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 656| 3.16k| do { \ | | 657| 3.16k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.16k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.16k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.16k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 3.16k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.16k] | | ------------------ ------------------ 214| | 215| 3.16k| IGRAPH_FREE(str2); ------------------ | | 36| 3.16k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 216| 3.16k| IGRAPH_FINALLY_CLEAN(5); 217| | 218| 3.16k| VECTOR(t->values)[i] = newvalue; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 219| 3.16k| VECTOR(t->children)[i] = node; ------------------ | | 60| 3.16k|#define VECTOR(v) ((v).stor_begin) ------------------ 220| | 221| 3.16k| *id = newvalue; 222| 3.16k| return IGRAPH_SUCCESS; 223| | 224| 3.81k| } else if (add) { ------------------ | Branch (224:20): [True: 3.81k, False: 0] ------------------ 225| | 226| | /* ------------------------------------ */ 227| | /* the first diff characters match */ 228| 3.81k| char *str2; 229| | 230| 3.81k| igraph_trie_node_t *node = IGRAPH_CALLOC(1, igraph_trie_node_t); ------------------ | | 33| 3.81k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 7.63k| (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.81k, Folded] | | | | ------------------ | | ------------------ ------------------ 231| 3.81k| IGRAPH_CHECK_OOM(node, "Cannot add to trie."); ------------------ | | 709| 3.81k| do { \ | | 710| 3.81k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | ------------------ | | ------------------ | | 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.81k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.81k] | | ------------------ ------------------ 232| 3.81k| IGRAPH_FINALLY(igraph_free, node); ------------------ | | 603| 3.81k| do { \ | | 604| 3.81k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.81k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.81k| * incorrect destructor function with the pointer */ \ | | 607| 3.81k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.81k] | | ------------------ | | 608| 3.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.81k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.81k] | | ------------------ ------------------ 233| | 234| 3.81k| IGRAPH_STRVECTOR_INIT_FINALLY(&node->strs, 2); ------------------ | | 62| 3.81k| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 3.81k| do { \ | | | | 657| 3.81k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | | | ------------------ | | | | ------------------ | | | | 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.81k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.81k] | | | | ------------------ | | ------------------ | | 63| 3.81k| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 3.81k| do { \ | | | | 604| 3.81k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.81k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.81k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.81k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.81k] | | | | ------------------ | | | | 608| 3.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.81k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.81k] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 3.81k] | | ------------------ ------------------ 235| 3.81k| IGRAPH_VECTOR_PTR_INIT_FINALLY(&node->children, 2); ------------------ | | 46| 3.81k| do { IGRAPH_CHECK(igraph_vector_ptr_init(v, size)); \ | | ------------------ | | | | 656| 3.81k| do { \ | | | | 657| 3.81k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | | | ------------------ | | | | ------------------ | | | | 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.81k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.81k] | | | | ------------------ | | ------------------ | | 47| 3.81k| IGRAPH_FINALLY(igraph_vector_ptr_destroy, v); } while (0) | | ------------------ | | | | 603| 3.81k| do { \ | | | | 604| 3.81k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.81k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.81k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.81k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.81k] | | | | ------------------ | | | | 608| 3.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.81k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.81k] | | | | ------------------ | | ------------------ | | | Branch (47:65): [Folded, False: 3.81k] | | ------------------ ------------------ 236| 3.81k| IGRAPH_VECTOR_INT_INIT_FINALLY(&node->values, 2); ------------------ | | 119| 3.81k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 3.81k| do { \ | | | | 657| 3.81k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 3.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | | | ------------------ | | | | ------------------ | | | | 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.81k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 3.81k] | | | | ------------------ | | ------------------ | | 120| 3.81k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 3.81k| do { \ | | | | 604| 3.81k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 3.81k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 3.81k| * incorrect destructor function with the pointer */ \ | | | | 607| 3.81k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 3.81k] | | | | ------------------ | | | | 608| 3.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 3.81k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 3.81k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 3.81k] | | ------------------ ------------------ 237| 3.81k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 0, str + diff)); ------------------ | | 656| 3.81k| do { \ | | 657| 3.81k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | ------------------ | | ------------------ | | 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.81k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.81k] | | ------------------ ------------------ 238| 3.81k| IGRAPH_CHECK(igraph_strvector_set(&node->strs, 1, key + diff)); ------------------ | | 656| 3.81k| do { \ | | 657| 3.81k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | ------------------ | | ------------------ | | 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.81k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.81k] | | ------------------ ------------------ 239| 3.81k| VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->children)[0] = VECTOR(t->children)[i]; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ 240| 3.81k| VECTOR(node->children)[1] = 0; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ 241| 3.81k| VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(node->values)[0] = VECTOR(t->values)[i]; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ 242| 3.81k| VECTOR(node->values)[1] = newvalue; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ 243| | 244| 3.81k| str2 = strdup(str); 245| 3.81k| IGRAPH_CHECK_OOM(str2, "Cannot add to trie."); ------------------ | | 709| 3.81k| do { \ | | 710| 3.81k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | ------------------ | | ------------------ | | 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.81k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.81k] | | ------------------ ------------------ 246| | 247| 3.81k| str2[diff] = '\0'; 248| 3.81k| IGRAPH_FINALLY(igraph_free, str2); ------------------ | | 603| 3.81k| do { \ | | 604| 3.81k| /* the following branch makes the compiler check the compatibility of \ | | 605| 3.81k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 3.81k| * incorrect destructor function with the pointer */ \ | | 607| 3.81k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 3.81k] | | ------------------ | | 608| 3.81k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 3.81k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 3.81k] | | ------------------ ------------------ 249| | 250| 3.81k| IGRAPH_CHECK(igraph_strvector_set(&t->strs, i, str2)); ------------------ | | 656| 3.81k| do { \ | | 657| 3.81k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.81k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.81k] | | | | ------------------ | | ------------------ | | 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.81k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.81k] | | ------------------ ------------------ 251| | 252| 3.81k| IGRAPH_FREE(str2); ------------------ | | 36| 3.81k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 253| 3.81k| IGRAPH_FINALLY_CLEAN(5); 254| | 255| 3.81k| VECTOR(t->values)[i] = -1; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ 256| 3.81k| VECTOR(t->children)[i] = node; ------------------ | | 60| 3.81k|#define VECTOR(v) ((v).stor_begin) ------------------ 257| | 258| 3.81k| *id = newvalue; 259| 3.81k| return IGRAPH_SUCCESS; 260| 3.81k| } 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.86M| } 268| | 269| | /* ------------------------------------ */ 270| | /* Nothing matches */ 271| | 272| 11.4k| if (add) { ------------------ | Branch (272:9): [True: 11.4k, False: 0] ------------------ 273| | /* Memory saving at the cost of performance may be possible by using the pattern 274| | * CHECK(reserve(vec, size(vec) + 1)); 275| | * push_back(vec, value); 276| | * This was the original pattern used before igraph 0.10. */ 277| 11.4k| IGRAPH_CHECK(igraph_strvector_push_back(&t->strs, key)); ------------------ | | 656| 11.4k| do { \ | | 657| 11.4k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 11.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 11.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.4k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 11.4k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 11.4k] | | ------------------ ------------------ 278| 11.4k| IGRAPH_CHECK(igraph_vector_ptr_push_back(&t->children, NULL)); ------------------ | | 656| 11.4k| do { \ | | 657| 11.4k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 11.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 11.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.4k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 11.4k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 11.4k] | | ------------------ ------------------ 279| 11.4k| IGRAPH_CHECK(igraph_vector_int_push_back(&t->values, newvalue)); ------------------ | | 656| 11.4k| do { \ | | 657| 11.4k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 11.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 11.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.4k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 11.4k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 11.4k] | | ------------------ ------------------ 280| 11.4k| *id = newvalue; 281| 11.4k| } else { 282| 0| *id = -1; 283| 0| } 284| | 285| 11.4k| return IGRAPH_SUCCESS; 286| 11.4k|} trie.c:igraph_i_strdiff: 111| 6.86M|static size_t igraph_i_strdiff(const char *str, const char *key) { 112| 6.86M| size_t diff = 0; 113| 8.28M| while (key[diff] != '\0' && str[diff] != '\0' && str[diff] == key[diff]) { ------------------ | Branch (113:12): [True: 7.75M, False: 534k] | Branch (113:33): [True: 7.25M, False: 500k] | Branch (113:54): [True: 1.42M, False: 5.82M] ------------------ 114| 1.42M| diff++; 115| 1.42M| } 116| 6.86M| return diff; 117| 6.86M|} igraph_attribute_record_list_init: 109| 2.86k|igraph_error_t FUNCTION(init)(TYPE *v, igraph_int_t size) { 110| 2.86k| igraph_int_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (110:31): [True: 424, False: 2.43k] ------------------ 111| 2.86k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 2.86k| do { \ | | 925| 2.86k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.86k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.86k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.86k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.86k] | | ------------------ ------------------ 112| 2.86k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE); ------------------ | | 33| 2.86k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 5.72k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 2.86k, False: 0] | | | | | Branch (31:24): [True: 2.86k, False: 0] | | | | | Branch (31:66): [True: 2.86k, False: 0] | | | | ------------------ | | ------------------ ------------------ 113| 2.86k| if (v->stor_begin == 0) { ------------------ | Branch (113:9): [True: 0, False: 2.86k] ------------------ 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.86k| v->stor_end = v->stor_begin + alloc_size; 117| 2.86k| v->end = v->stor_begin + size; 118| | 119| 2.86k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end)); ------------------ | | 656| 2.86k| do { \ | | 657| 2.86k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.86k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.86k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.86k] | | | | ------------------ | | ------------------ | | 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.86k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.86k] | | ------------------ ------------------ 120| | 121| 2.86k| return IGRAPH_SUCCESS; 122| 2.86k|} igraph_attribute_record_list_destroy: 176| 2.86k|void FUNCTION(destroy)(TYPE *v) { 177| 2.86k| IGRAPH_ASSERT(v != 0); ------------------ | | 924| 2.86k| do { \ | | 925| 2.86k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.86k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.86k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.86k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.86k] | | ------------------ ------------------ 178| | 179| 2.86k| if (v->stor_begin != 0) { ------------------ | Branch (179:9): [True: 2.86k, False: 0] ------------------ 180| 2.86k| FUNCTION(clear)(v); ------------------ | | 161| 2.86k| #define FUNCTION(c) CONCAT2x(igraph_attribute_record_list,c) | | ------------------ | | | | 19| 2.86k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 181| 2.86k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 2.86k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 182| | v->stor_begin = NULL; 183| 2.86k| } 184| 2.86k|} igraph_attribute_record_list_size: 287| 3.18k|igraph_int_t FUNCTION(size)(const TYPE *v) { 288| 3.18k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 3.18k| do { \ | | 925| 3.18k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.18k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.18k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.18k] | | ------------------ ------------------ 289| 3.18k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 3.18k| do { \ | | 925| 3.18k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.18k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.18k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.18k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.18k] | | ------------------ ------------------ 290| 3.18k| return v->end - v->stor_begin; 291| 3.18k|} igraph_attribute_record_list_clear: 357| 2.86k|void FUNCTION(clear)(TYPE *v) { 358| 2.86k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.86k| do { \ | | 925| 2.86k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.86k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.86k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.86k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.86k] | | ------------------ ------------------ 359| 2.86k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 2.86k| do { \ | | 925| 2.86k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.86k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.86k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.86k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.86k] | | ------------------ ------------------ 360| 2.86k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end); ------------------ | | 162| 2.86k| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 2.86k|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 361| 2.86k| v->end = v->stor_begin; 362| 2.86k|} igraph_attribute_record_list_get_ptr: 377| 1.81k|ITEM_TYPE *FUNCTION(get_ptr)(const TYPE *v, igraph_int_t pos) { 378| 1.81k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 1.81k| do { \ | | 925| 1.81k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.81k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.81k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.81k] | | ------------------ ------------------ 379| 1.81k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 1.81k| do { \ | | 925| 1.81k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.81k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.81k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.81k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.81k] | | ------------------ ------------------ 380| 1.81k| return v->stor_begin + pos; 381| 1.81k|} igraph_attribute_record_list_push_back_new: 640| 314|igraph_error_t FUNCTION(push_back_new)(TYPE *v, ITEM_TYPE** e) { 641| 314| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v)); ------------------ | | 656| 314| do { \ | | 657| 314| igraph_error_t igraph_i_ret = (expr); \ | | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 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| 314| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 314] | | ------------------ ------------------ 642| 314| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end)); ------------------ | | 656| 314| do { \ | | 657| 314| igraph_error_t igraph_i_ret = (expr); \ | | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 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| 314| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 314] | | ------------------ ------------------ 643| 314| if (e) { ------------------ | Branch (643:9): [True: 314, False: 0] ------------------ 644| 314| *e = v->end; 645| 314| } 646| 314| v->end += 1; 647| 314| return IGRAPH_SUCCESS; 648| 314|} attributes.c:igraph_i_attribute_record_list_init_slice: 1068| 2.86k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1069| 2.86k| ITEM_TYPE *current; ------------------ | | 61| 2.86k| #define ITEM_TYPE BASE | | ------------------ | | | | 115| 2.86k| #define BASE igraph_attribute_record_t | | ------------------ ------------------ 1070| 2.86k| igraph_error_t retval; 1071| | 1072| 3.28k| for (current = start; current < end; current++) { ------------------ | Branch (1072:27): [True: 424, False: 2.86k] ------------------ 1073| 424| retval = INTERNAL_FUNCTION(init_item)(list, current); ------------------ | | 162| 424| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 424|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1074| 424| if (retval) { ------------------ | Branch (1074:13): [True: 0, False: 424] ------------------ 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| 424| } 1079| | 1080| 2.86k| return IGRAPH_SUCCESS; 1081| 2.86k|} attributes.c:igraph_i_attribute_record_list_destroy_slice: 1083| 2.86k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE *list, ITEM_TYPE *start, ITEM_TYPE *end) { 1084| 2.86k| IGRAPH_UNUSED(list); ------------------ | | 30| 2.86k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 1085| 3.60k| for (; start < end; start++) { ------------------ | Branch (1085:12): [True: 738, False: 2.86k] ------------------ 1086| 738| INTERNAL_FUNCTION(destroy_item)(start); ------------------ | | 162| 738| #define INTERNAL_FUNCTION(c) CONCAT2x(igraph_i_attribute_record_list,c) | | ------------------ | | | | 19| 738|#define CONCAT2x(a,b) a ## _ ## b | | ------------------ ------------------ 1087| 738| } 1088| 2.86k|} attributes.c:igraph_i_attribute_record_list_expand_if_full: 1094| 314|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE *v) { 1095| 314| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 314| do { \ | | 925| 314| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 314| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 314] | | ------------------ ------------------ 1096| 314| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 314| do { \ | | 925| 314| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 314| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 314] | | ------------------ ------------------ 1097| | 1098| 314| if (v->stor_end == v->end) { ------------------ | Branch (1098:9): [True: 0, False: 314] ------------------ 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| 314| return IGRAPH_SUCCESS; 1111| 314|} igraph_vector_int_pair_order: 119| 976| igraph_vector_int_t* res, igraph_int_t nodes) { 120| 976| igraph_int_t edges = igraph_vector_int_size(v); 121| 976| igraph_vector_int_t ptr; 122| 976| igraph_vector_int_t rad; 123| 976| igraph_int_t i, j; 124| | 125| 976| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 976| do { \ | | 925| 976| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 976| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 976] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 976| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 976] | | ------------------ ------------------ 126| 976| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 976| do { \ | | 925| 976| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 976| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 976] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 976| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 976] | | ------------------ ------------------ 127| | 128| 976| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1); ------------------ | | 119| 976| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 976| do { \ | | | | 657| 976| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 976| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 976| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 976] | | | | | | ------------------ | | | | ------------------ | | | | 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| 976| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 976] | | | | ------------------ | | ------------------ | | 120| 976| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 976| do { \ | | | | 604| 976| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 976| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 976| * incorrect destructor function with the pointer */ \ | | | | 607| 976| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 976] | | | | ------------------ | | | | 608| 976| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 976| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 976] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 976] | | ------------------ ------------------ 129| 976| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges); ------------------ | | 119| 976| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 976| do { \ | | | | 657| 976| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 976| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 976| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 976] | | | | | | ------------------ | | | | ------------------ | | | | 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| 976| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 976] | | | | ------------------ | | ------------------ | | 120| 976| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 976| do { \ | | | | 604| 976| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 976| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 976| * incorrect destructor function with the pointer */ \ | | | | 607| 976| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 976] | | | | ------------------ | | | | 608| 976| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 976| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 976] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 976] | | ------------------ ------------------ 130| 976| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 656| 976| do { \ | | 657| 976| igraph_error_t igraph_i_ret = (expr); \ | | 658| 976| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 976| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 976] | | | | ------------------ | | ------------------ | | 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| 976| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 976] | | ------------------ ------------------ 131| | 132| 6.32M| for (i = 0; i < edges; i++) { ------------------ | Branch (132:17): [True: 6.32M, False: 976] ------------------ 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.4k] ------------------ 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| 976| j = 0; 141| 75.6M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (141:17): [True: 75.6M, False: 976] ------------------ 142| 75.6M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 60| 75.6M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (142:13): [True: 35.4k, False: 75.6M] ------------------ 143| 35.4k| igraph_int_t next = VECTOR(ptr)[i] - 1; ------------------ | | 60| 35.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 144| 35.4k| VECTOR(*res)[j++] = next; ------------------ | | 60| 35.4k|#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.4k] ------------------ 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.4k| } 150| 75.6M| } 151| | 152| 976| igraph_vector_int_null(&ptr); 153| 976| igraph_vector_int_null(&rad); 154| | 155| 6.32M| for (i = 0; i < edges; i++) { ------------------ | Branch (155:17): [True: 6.32M, False: 976] ------------------ 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.4k] ------------------ 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| 976| j = 0; 165| 75.6M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (165:17): [True: 75.6M, False: 976] ------------------ 166| 75.6M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 60| 75.6M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (166:13): [True: 35.4k, False: 75.6M] ------------------ 167| 35.4k| igraph_int_t next = VECTOR(ptr)[i] - 1; ------------------ | | 60| 35.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 168| 35.4k| VECTOR(*res)[j++] = next; ------------------ | | 60| 35.4k|#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.4k] ------------------ 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.4k| } 174| 75.6M| } 175| | 176| 976| igraph_vector_int_destroy(&ptr); 177| 976| igraph_vector_int_destroy(&rad); 178| 976| IGRAPH_FINALLY_CLEAN(2); 179| | 180| 976| return IGRAPH_SUCCESS; 181| 976|} igraph_vector_init: 134| 2.71k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) { 135| 2.71k| igraph_int_t alloc_size; 136| 2.71k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 2.71k| do { \ | | 925| 2.71k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.71k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.71k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.71k] | | ------------------ ------------------ 137| 2.71k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (137:18): [True: 0, False: 2.71k] ------------------ 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.71k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 33| 2.71k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 5.42k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 2.71k, False: 0] | | | | | Branch (31:24): [True: 2.71k, False: 0] | | | | | Branch (31:66): [True: 2.71k, False: 0] | | | | ------------------ | | ------------------ ------------------ 144| 2.71k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector."); ------------------ | | 709| 2.71k| do { \ | | 710| 2.71k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 2.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.71k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 2.71k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 2.71k] | | ------------------ ------------------ 145| 2.71k| v->stor_end = v->stor_begin + alloc_size; 146| 2.71k| v->end = v->stor_begin + size; 147| | 148| 2.71k| return IGRAPH_SUCCESS; 149| 2.71k|} igraph_vector_destroy: 408| 2.71k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) { 409| 2.71k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.71k| do { \ | | 925| 2.71k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.71k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.71k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.71k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.71k] | | ------------------ ------------------ 410| | /* vector_init() will leave stor_begin set to NULL when it fails. 411| | * We handle these cases gracefully. */ 412| 2.71k| if (v->stor_begin != NULL) { ------------------ | Branch (412:9): [True: 2.71k, False: 0] ------------------ 413| 2.71k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 2.71k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 414| | v->stor_begin = NULL; 415| 2.71k| } 416| 2.71k|} 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.25k] ------------------ 479| 36.6k| return IGRAPH_SUCCESS; 480| 36.6k| } 481| | 482| 1.25k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 35| 1.25k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 2.50k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 1.25k, False: 0] | | | | | Branch (31:24): [True: 1.25k, False: 0] | | | | | Branch (31:66): [True: 1.25k, False: 0] | | | | ------------------ | | ------------------ ------------------ 483| 1.25k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 709| 1.25k| do { \ | | 710| 1.25k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 1.25k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.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| 1.25k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 1.25k] | | ------------------ ------------------ 484| | 485| 1.25k| v->end = tmp + (v->end - v->stor_begin); 486| 1.25k| v->stor_begin = tmp; 487| 1.25k| v->stor_end = v->stor_begin + capacity; 488| | 489| 1.25k| return IGRAPH_SUCCESS; 490| 1.25k|} 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: 664, False: 37.9k] ------------------ 578| | /* full, allocate more storage */ 579| 664| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 170| 664| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 664|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 664|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 580| 664| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 664|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 664|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (580:33): [True: 664, False: 0] ------------------ 581| 664| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 664|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (581:13): [True: 0, False: 664] ------------------ 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| 664| if (new_size == 0) { ------------------ | Branch (584:13): [True: 0, False: 664] ------------------ 585| 0| new_size = 1; 586| 0| } 587| 664| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 664| do { \ | | 657| 664| igraph_error_t igraph_i_ret = (expr); \ | | 658| 664| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 664| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 664] | | | | ------------------ | | ------------------ | | 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| 664| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 664] | | ------------------ ------------------ 588| 664| } 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| 145| const TYPE(igraph_vector) *from) { 2428| 145| IGRAPH_ASSERT(to != NULL); ------------------ | | 924| 145| do { \ | | 925| 145| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 145| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 145] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 145| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 145] | | ------------------ ------------------ 2429| 145| IGRAPH_ASSERT(to->stor_begin != NULL); ------------------ | | 924| 145| do { \ | | 925| 145| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 145| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 145] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 145| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 145] | | ------------------ ------------------ 2430| | 2431| 145| const igraph_int_t to_size = FUNCTION(igraph_vector, size)(to); ------------------ | | 170| 145| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 145|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 145|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2432| 145| const igraph_int_t from_size = FUNCTION(igraph_vector, size)(from); ------------------ | | 170| 145| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 145|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 145|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2433| 145| const igraph_int_t to_capacity = FUNCTION(igraph_vector, capacity)(to); ------------------ | | 170| 145| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 20| 145|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 145|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2434| 145| igraph_int_t new_to_size; 2435| | 2436| 145| IGRAPH_SAFE_ADD(to_size, from_size, &new_to_size); ------------------ | | 47| 145| do { \ | | 48| 145| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 145| igraph_int_t _safe_sum; \ | | 50| 145| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 145] | | ------------------ | | 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| 145| *(res) = _safe_sum; \ | | 54| 145| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 145] | | ------------------ ------------------ 2437| | 2438| 145| if (to_capacity < new_to_size) { ------------------ | Branch (2438:9): [True: 139, False: 6] ------------------ 2439| 139| igraph_int_t new_to_capacity = to_capacity < IGRAPH_INTEGER_MAX/2 ? to_capacity * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 139|# 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| 139|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (2439:40): [True: 139, False: 0] ------------------ 2440| 139| if (new_to_capacity < new_to_size) { ------------------ | Branch (2440:13): [True: 136, False: 3] ------------------ 2441| 136| new_to_capacity = new_to_size; 2442| 136| } 2443| 139| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(to, new_to_capacity)); ------------------ | | 656| 139| do { \ | | 657| 139| igraph_error_t igraph_i_ret = (expr); \ | | 658| 139| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 139| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 139] | | | | ------------------ | | ------------------ | | 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| 139| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 139] | | ------------------ ------------------ 2444| 139| } 2445| | 2446| 145| memcpy(to->stor_begin + to_size, from->stor_begin, 2447| 145| sizeof(BASE) * from_size); 2448| 145| to->end = to->stor_begin + new_to_size; 2449| | 2450| 145| return IGRAPH_SUCCESS; 2451| 145|} igraph_vector_swap: 2541| 255|void FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) { 2542| | 2543| 255| TYPE(igraph_vector) tmp; ------------------ | | 171| 255| #define TYPE(a) CONCAT2(a,t) | | ------------------ | | | | 20| 255|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 19| 255|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 2544| | 2545| 255| tmp = *v1; 2546| 255| *v1 = *v2; 2547| 255| *v2 = tmp; 2548| 255|} igraph_vector_int_init: 134| 20.7k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector) *v, igraph_int_t size) { 135| 20.7k| igraph_int_t alloc_size; 136| 20.7k| IGRAPH_ASSERT(size >= 0); ------------------ | | 924| 20.7k| do { \ | | 925| 20.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 20.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 20.7k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 20.7k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 20.7k] | | ------------------ ------------------ 137| 20.7k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (137:18): [True: 11.6k, False: 9.14k] ------------------ 138| | 139| | /* When this function fails, it should leave stor_begin set to NULL, 140| | * so that vector_destroy() is still safe to call on the vector. 141| | * This simplifies freeing partially initialized data structures, 142| | * such as adjacency lists, when an error occurs mid-initialization. */ 143| 20.7k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 33| 20.7k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 41.5k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 20.7k, False: 0] | | | | | Branch (31:24): [True: 20.7k, False: 0] | | | | | Branch (31:66): [True: 20.7k, False: 0] | | | | ------------------ | | ------------------ ------------------ 144| 20.7k| IGRAPH_CHECK_OOM(v->stor_begin, "Insufficient memory to initialize vector."); ------------------ | | 709| 20.7k| do { \ | | 710| 20.7k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 20.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 20.7k] | | | | ------------------ | | ------------------ | | 711| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 712| 0| } \ | | 713| 20.7k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 20.7k] | | ------------------ ------------------ 145| 20.7k| v->stor_end = v->stor_begin + alloc_size; 146| 20.7k| v->end = v->stor_begin + size; 147| | 148| 20.7k| return IGRAPH_SUCCESS; 149| 20.7k|} igraph_vector_int_destroy: 408| 20.7k|void FUNCTION(igraph_vector, destroy)(TYPE(igraph_vector) *v) { 409| 20.7k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 20.7k| do { \ | | 925| 20.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 20.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 20.7k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 20.7k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 20.7k] | | ------------------ ------------------ 410| | /* vector_init() will leave stor_begin set to NULL when it fails. 411| | * We handle these cases gracefully. */ 412| 20.7k| if (v->stor_begin != NULL) { ------------------ | Branch (412:9): [True: 20.7k, False: 0] ------------------ 413| 20.7k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 20.7k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 414| | v->stor_begin = NULL; 415| 20.7k| } 416| 20.7k|} igraph_vector_int_capacity: 436| 17.4k|igraph_int_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector) *v) { 437| 17.4k| return v->stor_end - v->stor_begin; 438| 17.4k|} igraph_vector_int_reserve: 468| 17.4k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector) *v, igraph_int_t capacity) { 469| 17.4k| igraph_int_t current_capacity; 470| 17.4k| BASE *tmp; ------------------ | | 66| 17.4k| #define BASE igraph_int_t ------------------ 471| | 472| 17.4k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 17.4k| do { \ | | 925| 17.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.4k] | | ------------------ ------------------ 473| 17.4k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 17.4k| do { \ | | 925| 17.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.4k] | | ------------------ ------------------ 474| 17.4k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 17.4k| do { \ | | 925| 17.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.4k] | | ------------------ ------------------ 475| | 476| 17.4k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 178| 17.4k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 17.4k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 17.4k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 477| | 478| 17.4k| if (capacity <= current_capacity) { ------------------ | Branch (478:9): [True: 7.07k, False: 10.4k] ------------------ 479| 7.07k| return IGRAPH_SUCCESS; 480| 7.07k| } 481| | 482| 10.4k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 35| 10.4k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 20.8k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 10.4k, False: 0] | | | | | Branch (31:24): [True: 10.4k, False: 0] | | | | | Branch (31:66): [True: 10.4k, False: 0] | | | | ------------------ | | ------------------ ------------------ 483| 10.4k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 709| 10.4k| do { \ | | 710| 10.4k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 10.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.4k] | | | | ------------------ | | ------------------ | | 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.4k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 10.4k] | | ------------------ ------------------ 484| | 485| 10.4k| v->end = tmp + (v->end - v->stor_begin); 486| 10.4k| v->stor_begin = tmp; 487| 10.4k| v->stor_end = v->stor_begin + capacity; 488| | 489| 10.4k| return IGRAPH_SUCCESS; 490| 10.4k|} igraph_vector_int_empty: 503| 591|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector) *v) { 504| 591| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 591| do { \ | | 925| 591| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 591| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 591] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 591| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 591] | | ------------------ ------------------ 505| 591| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 591| do { \ | | 925| 591| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 591| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 591] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 591| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 591] | | ------------------ ------------------ 506| 591| return v->stor_begin == v->end; 507| 591|} igraph_vector_int_size: 522| 58.0k|igraph_int_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector) *v) { 523| 58.0k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 58.0k| do { \ | | 925| 58.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 58.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 58.0k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 58.0k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 58.0k] | | ------------------ ------------------ 524| 58.0k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 58.0k| do { \ | | 925| 58.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 58.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 58.0k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 58.0k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 58.0k] | | ------------------ ------------------ 525| 58.0k| return v->end - v->stor_begin; 526| 58.0k|} 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: 7.78k, False: 14.1M] ------------------ 578| | /* full, allocate more storage */ 579| 7.78k| igraph_int_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 178| 7.78k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 7.78k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 7.78k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 580| 7.78k| igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.78k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_int_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 72| 7.78k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (580:33): [True: 7.78k, False: 0] ------------------ 581| 7.78k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 72| 7.78k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (581:13): [True: 0, False: 7.78k] ------------------ 582| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 426| 0| do { \ | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 0| return igraph_errno ; \ | | 429| 0| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 583| 0| } 584| 7.78k| if (new_size == 0) { ------------------ | Branch (584:13): [True: 0, False: 7.78k] ------------------ 585| 0| new_size = 1; 586| 0| } 587| 7.78k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 7.78k| do { \ | | 657| 7.78k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 7.78k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 7.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 7.78k] | | | | ------------------ | | ------------------ | | 659| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 0| do { \ | | | | 427| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 0| return igraph_errno ; \ | | | | 429| 0| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 0| } \ | | 661| 7.78k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 7.78k] | | ------------------ ------------------ 588| 7.78k| } 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.24k|void FUNCTION(igraph_vector, null)(TYPE(igraph_vector) *v) { 726| 2.24k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 2.24k| do { \ | | 925| 2.24k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.24k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.24k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.24k] | | ------------------ ------------------ 727| 2.24k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 2.24k| do { \ | | 925| 2.24k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.24k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.24k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.24k] | | ------------------ ------------------ 728| 2.24k| if (FUNCTION(igraph_vector, size)(v) > 0) { ------------------ | | 178| 2.24k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 2.24k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 2.24k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ | Branch (728:9): [True: 1.95k, False: 294] ------------------ 729| 1.95k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v)); ------------------ | | 178| 1.95k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 22| 1.95k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 21| 1.95k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 730| 1.95k| } 731| 2.24k|} igraph_vector_int_resize: 1264| 5.47k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_int_t new_size) { 1265| 5.47k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 5.47k| do { \ | | 925| 5.47k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 5.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.47k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 5.47k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 5.47k] | | ------------------ ------------------ 1266| 5.47k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 5.47k| do { \ | | 925| 5.47k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 5.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.47k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 5.47k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 5.47k] | | ------------------ ------------------ 1267| 5.47k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 656| 5.47k| do { \ | | 657| 5.47k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 5.47k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 5.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 5.47k] | | | | ------------------ | | ------------------ | | 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.47k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 5.47k] | | ------------------ ------------------ 1268| 5.47k| v->end = v->stor_begin + new_size; 1269| 5.47k| return IGRAPH_SUCCESS; 1270| 5.47k|} igraph_vector_int_max: 1327| 591|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector) *v) { 1328| 591| BASE max; ------------------ | | 66| 591| #define BASE igraph_int_t ------------------ 1329| 591| BASE *ptr; ------------------ | | 66| 591| #define BASE igraph_int_t ------------------ 1330| 591| IGRAPH_ASSERT(!FUNCTION(igraph_vector, empty)(v)); ------------------ | | 924| 591| do { \ | | 925| 591| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 591| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 591] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 591| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 591] | | ------------------ ------------------ 1331| 591| max = *(v->stor_begin); 1332| |#if defined(BASE_IGRAPH_REAL) 1333| | if (isnan(max)) { return max; }; /* Result is NaN */ 1334| |#endif 1335| 591| ptr = v->stor_begin + 1; 1336| 6.48M| while (ptr < v->end) { ------------------ | Branch (1336:12): [True: 6.48M, False: 591] ------------------ 1337| 6.48M| if ((*ptr) > max) { ------------------ | Branch (1337:13): [True: 38.0k, False: 6.44M] ------------------ 1338| 38.0k| max = *ptr; 1339| 38.0k| } 1340| |#if defined(BASE_IGRAPH_REAL) 1341| | else if (isnan(*ptr)) 1342| | return *ptr; /* Result is NaN */ 1343| |#endif 1344| 6.48M| ptr++; 1345| 6.48M| } 1346| 591| return max; 1347| 591|} igraph_vector_int_isininterval: 1832| 680| BASE high) { 1833| 680| BASE *ptr; ------------------ | | 66| 680| #define BASE igraph_int_t ------------------ 1834| 680| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 680| do { \ | | 925| 680| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 680| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 680] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 680| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 680] | | ------------------ ------------------ 1835| 680| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 680| do { \ | | 925| 680| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 680| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 680] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 680| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 680] | | ------------------ ------------------ 1836| 6.36M| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (1836:31): [True: 6.36M, False: 488] ------------------ 1837| | /* Note that the following is not equivalent to *ptr < low || *ptr > high 1838| | * when *ptr is NaN! */ 1839| 6.36M| if (!(*ptr >= low && *ptr <= high)) { ------------------ | Branch (1839:15): [True: 6.36M, False: 0] | Branch (1839:30): [True: 6.36M, False: 192] ------------------ 1840| 192| return 0; 1841| 192| } 1842| 6.36M| } 1843| 488| return 1; 1844| 680|} igraph_vector_ptr_init: 86| 10.6k|igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_int_t size) { 87| 10.6k| igraph_int_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (87:31): [True: 8.33k, False: 2.31k] ------------------ 88| 10.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 10.6k| do { \ | | 925| 10.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 10.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 10.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 10.6k] | | ------------------ ------------------ 89| 10.6k| if (size < 0) { ------------------ | Branch (89:9): [True: 0, False: 10.6k] ------------------ 90| 0| size = 0; 91| 0| } 92| 10.6k| v->stor_begin = IGRAPH_CALLOC(alloc_size, void*); ------------------ | | 33| 10.6k|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 21.2k| (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] | | | | ------------------ | | ------------------ ------------------ 93| 10.6k| if (v->stor_begin == 0) { ------------------ | Branch (93:9): [True: 0, False: 10.6k] ------------------ 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.6k| v->stor_end = v->stor_begin + alloc_size; 97| 10.6k| v->end = v->stor_begin + size; 98| 10.6k| v->item_destructor = 0; 99| | 100| 10.6k| return IGRAPH_SUCCESS; 101| 10.6k|} igraph_vector_ptr_destroy: 132| 10.6k|void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v) { 133| 10.6k| IGRAPH_ASSERT(v != 0); ------------------ | | 924| 10.6k| do { \ | | 925| 10.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 10.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 10.6k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 10.6k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 10.6k] | | ------------------ ------------------ 134| 10.6k| if (v->stor_begin != 0) { ------------------ | Branch (134:9): [True: 10.6k, False: 0] ------------------ 135| 10.6k| IGRAPH_FREE(v->stor_begin); ------------------ | | 36| 10.6k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 136| | v->stor_begin = NULL; 137| 10.6k| } 138| 10.6k|} igraph_vector_ptr_reserve: 215| 3.63k|igraph_error_t igraph_vector_ptr_reserve(igraph_vector_ptr_t* v, igraph_int_t capacity) { 216| 3.63k| igraph_int_t actual_size = igraph_vector_ptr_size(v); 217| 3.63k| void **tmp; 218| 3.63k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 3.63k| do { \ | | 925| 3.63k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.63k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.63k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.63k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.63k] | | ------------------ ------------------ 219| 3.63k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 3.63k| do { \ | | 925| 3.63k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.63k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.63k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.63k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.63k] | | ------------------ ------------------ 220| 3.63k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 924| 3.63k| do { \ | | 925| 3.63k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 3.63k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.63k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 3.63k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 3.63k] | | ------------------ ------------------ 221| | 222| 3.63k| if (capacity <= igraph_vector_ptr_size(v)) { ------------------ | Branch (222:9): [True: 0, False: 3.63k] ------------------ 223| 0| return IGRAPH_SUCCESS; 224| 0| } 225| | 226| 3.63k| tmp = IGRAPH_REALLOC(v->stor_begin, (size_t) capacity, void*); ------------------ | | 35| 3.63k|#define IGRAPH_REALLOC(p,n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, realloc((void*)(p), sizeof(t) * ((n) > 0 ? (n) : 1))) | | ------------------ | | | | 31| 7.27k| (t*) ((0 <= (n) && ((size_t)(n)) <= SIZE_MAX / sizeof(t)) ? (expr) : NULL) | | | | ------------------ | | | | | Branch (31:12): [True: 3.63k, False: 0] | | | | | Branch (31:24): [True: 3.63k, False: 0] | | | | | Branch (31:66): [True: 3.63k, False: 0] | | | | ------------------ | | ------------------ ------------------ 227| 3.63k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for pointer vector."); ------------------ | | 709| 3.63k| do { \ | | 710| 3.63k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 3.63k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.63k] | | | | ------------------ | | ------------------ | | 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.63k| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 3.63k] | | ------------------ ------------------ 228| | 229| 3.63k| v->stor_begin = tmp; 230| 3.63k| v->stor_end = v->stor_begin + capacity; 231| 3.63k| v->end = v->stor_begin + actual_size; 232| | 233| 3.63k| return IGRAPH_SUCCESS; 234| 3.63k|} igraph_vector_ptr_size: 291| 17.9k|igraph_int_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v) { 292| 17.9k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 17.9k| do { \ | | 925| 17.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.9k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.9k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.9k] | | ------------------ ------------------ 293| 17.9k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 17.9k| do { \ | | 925| 17.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 17.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 17.9k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 17.9k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 17.9k] | | ------------------ ------------------ 294| 17.9k| return v->end - v->stor_begin; 295| 17.9k|} igraph_vector_ptr_push_back: 360| 11.4k|igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e) { 361| 11.4k| IGRAPH_ASSERT(v != NULL); ------------------ | | 924| 11.4k| do { \ | | 925| 11.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 11.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 11.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 11.4k] | | ------------------ ------------------ 362| 11.4k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 924| 11.4k| do { \ | | 925| 11.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 11.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 11.4k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 11.4k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 11.4k] | | ------------------ ------------------ 363| | 364| | /* full, allocate more storage */ 365| 11.4k| if (v->stor_end == v->end) { ------------------ | Branch (365:9): [True: 3.63k, False: 7.85k] ------------------ 366| 3.63k| igraph_int_t new_size = igraph_vector_ptr_size(v) * 2; 367| 3.63k| if (new_size == 0) { ------------------ | Branch (367:13): [True: 0, False: 3.63k] ------------------ 368| 0| new_size = 1; 369| 0| } 370| 3.63k| IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size)); ------------------ | | 656| 3.63k| do { \ | | 657| 3.63k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 3.63k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 3.63k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 3.63k] | | | | ------------------ | | ------------------ | | 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.63k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 3.63k] | | ------------------ ------------------ 371| 3.63k| } 372| | 373| 11.4k| *(v->end) = e; 374| 11.4k| v->end += 1; 375| | 376| 11.4k| return IGRAPH_SUCCESS; 377| 11.4k|} igraph_attribute_record_init: 126| 738|) { 127| 738| attr->name = NULL; 128| 738| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 129| 738| attr->value.as_raw = NULL; 130| 738| attr->default_value.string = NULL; 131| | 132| 738| IGRAPH_CHECK(igraph_attribute_record_set_name(attr, name)); ------------------ | | 656| 738| do { \ | | 657| 738| igraph_error_t igraph_i_ret = (expr); \ | | 658| 738| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 738| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 738] | | | | ------------------ | | ------------------ | | 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| 738| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 738] | | ------------------ ------------------ 133| 738| IGRAPH_FINALLY(igraph_free, attr->name); ------------------ | | 603| 738| do { \ | | 604| 738| /* the following branch makes the compiler check the compatibility of \ | | 605| 738| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 738| * incorrect destructor function with the pointer */ \ | | 607| 738| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 738] | | ------------------ | | 608| 738| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 738| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 738] | | ------------------ ------------------ 134| 738| IGRAPH_CHECK(igraph_attribute_record_set_type(attr, type)); ------------------ | | 656| 738| do { \ | | 657| 738| igraph_error_t igraph_i_ret = (expr); \ | | 658| 738| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 738| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 738] | | | | ------------------ | | ------------------ | | 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| 738| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 738] | | ------------------ ------------------ 135| 738| IGRAPH_FINALLY_CLEAN(1); 136| | 137| 738| return IGRAPH_SUCCESS; 138| 738|} igraph_attribute_record_destroy: 241| 738|void igraph_attribute_record_destroy(igraph_attribute_record_t *attr) { 242| 738| igraph_i_attribute_record_destroy_values(attr); 243| | 244| 738| if (attr->name) { ------------------ | Branch (244:9): [True: 738, False: 0] ------------------ 245| 738| igraph_free(attr->name); 246| | attr->name = NULL; 247| 738| } 248| 738|} igraph_attribute_record_size: 295| 628|igraph_int_t igraph_attribute_record_size(const igraph_attribute_record_t *attr) { 296| 628| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 628| do { \ | | 925| 628| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 628| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 628] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 628| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 628] | | ------------------ ------------------ 297| | 298| 628| switch (attr->type) { 299| 290| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (299:9): [True: 290, False: 338] ------------------ 300| 290| return igraph_vector_size(attr->value.as_vector); 301| | 302| 338| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (302:9): [True: 338, False: 290] ------------------ 303| 338| return igraph_strvector_size(attr->value.as_strvector); 304| | 305| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (305:9): [True: 0, False: 628] ------------------ 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: 628] ------------------ 309| 0| return 0; 310| | 311| 0| default: ------------------ | Branch (311:9): [True: 0, False: 628] ------------------ 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| 628| } 314| 628|} igraph_attribute_record_resize: 332| 133|) { 333| 133| igraph_int_t i; 334| 133| igraph_vector_t *vec; 335| 133| igraph_vector_bool_t *log; 336| 133| igraph_strvector_t *str; 337| | 338| 133| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 133| do { \ | | 925| 133| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 133| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 133] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 133| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 133] | | ------------------ ------------------ 339| | 340| 133| switch (attr->type) { 341| | 342| 0| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (342:9): [True: 0, False: 133] ------------------ 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: 133] ------------------ 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| 133| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (360:9): [True: 133, False: 0] ------------------ 361| 133| str = attr->value.as_strvector; 362| 133| if (attr->default_value.string == 0 || (*attr->default_value.string == 0)) { ------------------ | Branch (362:17): [True: 133, False: 0] | Branch (362:52): [True: 0, False: 0] ------------------ 363| 133| IGRAPH_CHECK(igraph_strvector_resize(str, new_size)); ------------------ | | 656| 133| do { \ | | 657| 133| igraph_error_t igraph_i_ret = (expr); \ | | 658| 133| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 133| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 133] | | | | ------------------ | | ------------------ | | 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| 133| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 133] | | ------------------ ------------------ 364| 133| } 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| 133| break; 372| | 373| 133| case IGRAPH_ATTRIBUTE_UNSPECIFIED: ------------------ | Branch (373:9): [True: 0, False: 133] ------------------ 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: 133] ------------------ 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| 133| } 380| | 381| 133| return IGRAPH_SUCCESS; 382| 133|} igraph_attribute_record_set_default_numeric: 399| 400|) { 400| 400| if (attr->type != IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (400:9): [True: 0, False: 400] ------------------ 401| 0| return IGRAPH_EINVAL; 402| 0| } 403| | 404| 400| attr->default_value.numeric = value; 405| 400| return IGRAPH_SUCCESS; 406| 400|} igraph_attribute_record_set_name: 483| 1.47k|) { 484| 1.47k| char *new_name; 485| | 486| 1.47k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.47k| do { \ | | 925| 1.47k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.47k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.47k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.47k] | | ------------------ ------------------ 487| | 488| 1.47k| if (name != NULL) { ------------------ | Branch (488:9): [True: 738, False: 738] ------------------ 489| 738| new_name = strdup(name); 490| 738| IGRAPH_CHECK_OOM(new_name, "Insufficient memory for allocating attribute name."); ------------------ | | 709| 738| do { \ | | 710| 738| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 738| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 738] | | | | ------------------ | | ------------------ | | 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| 738| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 738] | | ------------------ ------------------ 491| 738| } else { 492| 738| new_name = NULL; 493| 738| } 494| | 495| 1.47k| if (attr->name) { ------------------ | Branch (495:9): [True: 0, False: 1.47k] ------------------ 496| 0| igraph_free(attr->name); 497| 0| } 498| | 499| 1.47k| attr->name = new_name; 500| | 501| 1.47k| return IGRAPH_SUCCESS; 502| 1.47k|} igraph_attribute_record_set_type: 539| 1.47k|) { 540| 1.47k| void *ptr; 541| | 542| 1.47k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.47k| do { \ | | 925| 1.47k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.47k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.47k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.47k] | | ------------------ ------------------ 543| | 544| 1.47k| if (attr->type != type) { ------------------ | Branch (544:9): [True: 738, False: 738] ------------------ 545| 738| switch (type) { 546| 400| case IGRAPH_ATTRIBUTE_NUMERIC: { ------------------ | Branch (546:13): [True: 400, False: 338] ------------------ 547| 400| igraph_vector_t *vec = IGRAPH_CALLOC(1, igraph_vector_t); ------------------ | | 33| 400|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 800| (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: 400, Folded] | | | | ------------------ | | ------------------ ------------------ 548| 400| IGRAPH_CHECK_OOM(vec, "Insufficient memory for attribute record."); ------------------ | | 709| 400| do { \ | | 710| 400| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 400| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 400] | | | | ------------------ | | ------------------ | | 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| 400| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 400] | | ------------------ ------------------ 549| 400| IGRAPH_FINALLY(igraph_free, vec); ------------------ | | 603| 400| do { \ | | 604| 400| /* the following branch makes the compiler check the compatibility of \ | | 605| 400| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 400| * incorrect destructor function with the pointer */ \ | | 607| 400| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 400] | | ------------------ | | 608| 400| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 400| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 400] | | ------------------ ------------------ 550| 400| IGRAPH_VECTOR_INIT_FINALLY(vec, 0); ------------------ | | 104| 400| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 656| 400| do { \ | | | | 657| 400| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 400| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 400| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 400] | | | | | | ------------------ | | | | ------------------ | | | | 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| 400| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 400] | | | | ------------------ | | ------------------ | | 105| 400| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 603| 400| do { \ | | | | 604| 400| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 400| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 400| * incorrect destructor function with the pointer */ \ | | | | 607| 400| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 400] | | | | ------------------ | | | | 608| 400| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 400| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 400] | | | | ------------------ | | ------------------ | | | Branch (105:60): [Folded, False: 400] | | ------------------ ------------------ 551| 400| ptr = vec; 552| 400| } 553| 0| break; 554| | 555| 338| case IGRAPH_ATTRIBUTE_STRING: { ------------------ | Branch (555:13): [True: 338, False: 400] ------------------ 556| 338| igraph_strvector_t *strvec = IGRAPH_CALLOC(1, igraph_strvector_t); ------------------ | | 33| 338|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 676| (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: 338, Folded] | | | | ------------------ | | ------------------ ------------------ 557| 338| IGRAPH_CHECK_OOM(strvec, "Insufficient memory for attribute record."); ------------------ | | 709| 338| do { \ | | 710| 338| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 338| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 338] | | | | ------------------ | | ------------------ | | 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| 338| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 338] | | ------------------ ------------------ 558| 338| IGRAPH_FINALLY(igraph_free, strvec); ------------------ | | 603| 338| do { \ | | 604| 338| /* the following branch makes the compiler check the compatibility of \ | | 605| 338| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 338| * incorrect destructor function with the pointer */ \ | | 607| 338| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 338] | | ------------------ | | 608| 338| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 338| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 338] | | ------------------ ------------------ 559| 338| IGRAPH_STRVECTOR_INIT_FINALLY(strvec, 0); ------------------ | | 62| 338| do { IGRAPH_CHECK(igraph_strvector_init(sv, size)); \ | | ------------------ | | | | 656| 338| do { \ | | | | 657| 338| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 338| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 338| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 338] | | | | | | ------------------ | | | | ------------------ | | | | 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| 338| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 338] | | | | ------------------ | | ------------------ | | 63| 338| IGRAPH_FINALLY( igraph_strvector_destroy, sv); } while (0) | | ------------------ | | | | 603| 338| do { \ | | | | 604| 338| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 338| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 338| * incorrect destructor function with the pointer */ \ | | | | 607| 338| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 338] | | | | ------------------ | | | | 608| 338| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 338| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 338] | | | | ------------------ | | ------------------ | | | Branch (63:65): [Folded, False: 338] | | ------------------ ------------------ 560| 338| ptr = strvec; 561| 338| } 562| 0| break; 563| | 564| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: { ------------------ | Branch (564:13): [True: 0, False: 738] ------------------ 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: 738] ------------------ 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| 738| } 576| | 577| 738| igraph_i_attribute_record_set_type(attr, type, ptr); 578| 738| IGRAPH_FINALLY_CLEAN(2); 579| 738| } 580| | 581| 1.47k| return IGRAPH_SUCCESS; 582| 1.47k|} igraph_i_attribute_init: 617| 813|) { 618| 813| graph->attr = NULL; 619| 813| if (igraph_i_attribute_table) { ------------------ | Branch (619:9): [True: 813, False: 0] ------------------ 620| 813| IGRAPH_CHECK(igraph_i_attribute_table->init(graph, attr)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 621| 813| if (graph->attr == NULL) { ------------------ | Branch (621:13): [True: 0, False: 813] ------------------ 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| 813| } 625| 813| return IGRAPH_SUCCESS; 626| 813|} igraph_i_attribute_destroy: 628| 813|void igraph_i_attribute_destroy(igraph_t *graph) { 629| 813| if (graph->attr && igraph_i_attribute_table) { ------------------ | Branch (629:9): [True: 813, False: 0] | Branch (629:24): [True: 813, False: 0] ------------------ 630| 813| igraph_i_attribute_table->destroy(graph); 631| 813| } 632| | graph->attr = NULL; 633| 813|} igraph_i_attribute_add_vertices: 649| 1.62k|) { 650| 1.62k| if (igraph_i_attribute_table) { ------------------ | Branch (650:9): [True: 1.62k, False: 0] ------------------ 651| 1.62k| return igraph_i_attribute_table->add_vertices(graph, nv, attr); 652| 1.62k| } else { 653| 0| return IGRAPH_SUCCESS; 654| 0| } 655| 1.62k|} igraph_i_attribute_add_edges: 690| 488|) { 691| 488| if (igraph_i_attribute_table) { ------------------ | Branch (691:9): [True: 488, False: 0] ------------------ 692| 488| return igraph_i_attribute_table->add_edges(graph, edges, attr); 693| 488| } else { 694| 0| return IGRAPH_SUCCESS; 695| 0| } 696| 488|} igraph_set_attribute_table: 895| 2.31k|igraph_set_attribute_table(const igraph_attribute_table_t * table) { 896| 2.31k| igraph_attribute_table_t *old = igraph_i_attribute_table; 897| 2.31k| igraph_i_attribute_table = (igraph_attribute_table_t*) table; 898| 2.31k| return old; 899| 2.31k|} attributes.c:igraph_i_attribute_record_destroy_values: 185| 1.47k|static void igraph_i_attribute_record_destroy_values(igraph_attribute_record_t *attr) { 186| 1.47k| IGRAPH_ASSERT(attr != NULL); ------------------ | | 924| 1.47k| do { \ | | 925| 1.47k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 1.47k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.47k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 1.47k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 1.47k] | | ------------------ ------------------ 187| | 188| 1.47k| if (attr->value.as_raw) { ------------------ | Branch (188:9): [True: 738, False: 738] ------------------ 189| 738| switch (attr->type) { 190| 400| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (190:13): [True: 400, False: 338] ------------------ 191| 400| igraph_vector_destroy(attr->value.as_vector); 192| 400| break; 193| | 194| 338| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (194:13): [True: 338, False: 400] ------------------ 195| 338| igraph_strvector_destroy(attr->value.as_strvector); 196| 338| break; 197| | 198| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (198:13): [True: 0, False: 738] ------------------ 199| 0| igraph_vector_bool_destroy(attr->value.as_vector_bool); 200| 0| break; 201| | 202| 0| default: ------------------ | Branch (202:13): [True: 0, False: 738] ------------------ 203| 0| break; 204| 738| } 205| | 206| 738| igraph_free(attr->value.as_raw); 207| 738| attr->value.as_raw = NULL; 208| 738| } 209| | 210| 1.47k| switch (attr->type) { 211| 400| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (211:9): [True: 400, False: 1.07k] ------------------ 212| 400| attr->default_value.numeric = 0; 213| 400| break; 214| | 215| 338| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (215:9): [True: 338, False: 1.13k] ------------------ 216| 338| if (attr->default_value.string) { ------------------ | Branch (216:17): [True: 0, False: 338] ------------------ 217| 0| igraph_free(attr->default_value.string); 218| 0| attr->default_value.string = NULL; 219| 0| } 220| 338| break; 221| | 222| 0| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (222:9): [True: 0, False: 1.47k] ------------------ 223| 0| attr->default_value.boolean = 0; 224| 0| break; 225| | 226| 738| default: ------------------ | Branch (226:9): [True: 738, False: 738] ------------------ 227| 738| break; 228| 1.47k| } 229| | 230| 1.47k| attr->type = IGRAPH_ATTRIBUTE_UNSPECIFIED; 231| 1.47k|} attributes.c:igraph_i_attribute_record_set_type: 506| 738|) { 507| 738| bool type_changed = attr->type != type; 508| | 509| 738| if (type_changed || attr->value.as_raw != ptr) { ------------------ | Branch (509:9): [True: 738, False: 0] | Branch (509:25): [True: 0, False: 0] ------------------ 510| 738| igraph_i_attribute_record_destroy_values(attr); 511| 738| attr->type = type; 512| 738| attr->value.as_raw = ptr; 513| 738| } 514| | 515| 738| if (type_changed && type == IGRAPH_ATTRIBUTE_NUMERIC) { ------------------ | Branch (515:9): [True: 738, False: 0] | Branch (515:25): [True: 400, False: 338] ------------------ 516| 400| IGRAPH_ASSERT( ------------------ | | 924| 400| do { \ | | 925| 400| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 400| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 400] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 400| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 400] | | ------------------ ------------------ 517| 400| igraph_attribute_record_set_default_numeric(attr, IGRAPH_NAN) == IGRAPH_SUCCESS 518| 400| ); 519| 400| } 520| 738|} attributes.c:igraph_i_attribute_record_list_init_item: 596| 738|) { 597| 738| IGRAPH_UNUSED(list); ------------------ | | 30| 738|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 598| | return igraph_attribute_record_init(item, NULL, IGRAPH_ATTRIBUTE_UNSPECIFIED); 599| 738|} attributes.c:igraph_i_attribute_record_list_destroy_item: 607| 738|static void igraph_i_attribute_record_list_destroy_item(igraph_attribute_record_t* item) { 608| 738| igraph_attribute_record_destroy(item); 609| 738|} igraph_i_property_cache_init: 32| 813|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) { 33| 813| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32); ------------------ | | 68| 813|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)])) ------------------ 34| | 35| 813| memset(cache->value, 0, sizeof(cache->value)); 36| 813| cache->known = 0; 37| 813| return IGRAPH_SUCCESS; 38| 813|} igraph_i_property_cache_destroy: 53| 813|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) { 54| 813| IGRAPH_UNUSED(cache); ------------------ | | 30| 813|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 55| | /* Nothing to do */ 56| 813|} igraph_i_property_cache_invalidate_conditionally: 182| 1.98k|) { 183| 1.98k| uint32_t invalidate = ~keep_always; 184| 1.98k| uint32_t mask; 185| 1.98k| uint32_t maybe_keep; 186| 1.98k| igraph_bool_t cached_value; 187| | 188| 1.98k| assert(graph->cache != NULL); ------------------ | Branch (188:5): [True: 0, False: 1.98k] | Branch (188:5): [True: 1.98k, 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.98k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true); 197| | 198| 1.98k| if (maybe_keep) { ------------------ | Branch (198:9): [True: 0, False: 1.98k] ------------------ 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.98k| graph->cache->known &= ~invalidate; 216| 1.98k|} cattributes.c:igraph_i_cattribute_init: 195| 813|) { 196| 813| igraph_i_cattributes_t *nattr; 197| | 198| 813| nattr = IGRAPH_CALLOC(1, igraph_i_cattributes_t); ------------------ | | 33| 813|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 1.62k| (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: 813, Folded] | | | | ------------------ | | ------------------ ------------------ 199| 813| IGRAPH_CHECK_OOM(nattr, "Insufficient memory to allocate attribute storage."); ------------------ | | 709| 813| do { \ | | 710| 813| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 813] | | ------------------ ------------------ 200| 813| IGRAPH_FINALLY(igraph_free, nattr); ------------------ | | 603| 813| do { \ | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 813| * incorrect destructor function with the pointer */ \ | | 607| 813| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 813] | | ------------------ | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 813| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 813] | | ------------------ ------------------ 201| | 202| 813| if (attr) { ------------------ | Branch (202:9): [True: 0, False: 813] ------------------ 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| 813| } else { 205| 813| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->gal, 0)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 206| 813| } 207| 813| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->gal); ------------------ | | 603| 813| do { \ | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 813| * incorrect destructor function with the pointer */ \ | | 607| 813| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 813] | | ------------------ | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 813| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 813] | | ------------------ ------------------ 208| | 209| 813| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->val, 0)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 210| 813| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->val); ------------------ | | 603| 813| do { \ | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 813| * incorrect destructor function with the pointer */ \ | | 607| 813| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 813] | | ------------------ | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 813| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 813] | | ------------------ ------------------ 211| | 212| 813| IGRAPH_CHECK(igraph_attribute_record_list_init(&nattr->eal, 0)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 213| 813| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &nattr->eal); ------------------ | | 603| 813| do { \ | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 813| * incorrect destructor function with the pointer */ \ | | 607| 813| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 813] | | ------------------ | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 813| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 813] | | ------------------ ------------------ 214| | 215| 813| graph->attr = nattr; 216| 813| IGRAPH_FINALLY_CLEAN(4); 217| | 218| 813| return IGRAPH_SUCCESS; 219| 813|} cattributes.c:igraph_i_cattribute_destroy: 221| 813|static void igraph_i_cattribute_destroy(igraph_t *graph) { 222| 813| igraph_i_cattributes_t *attr = graph->attr; 223| 813| igraph_attribute_record_list_destroy(&attr->eal); 224| 813| igraph_attribute_record_list_destroy(&attr->val); 225| 813| igraph_attribute_record_list_destroy(&attr->gal); 226| | IGRAPH_FREE(graph->attr); /* sets to NULL */ ------------------ | | 36| 813|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 227| 813|} cattributes.c:igraph_i_cattribute_add_vertices: 373| 1.62k|) { 374| 1.62k| igraph_i_cattributes_t *attr = graph->attr; 375| 1.62k| return igraph_i_cattribute_add_vertices_or_edges(&attr->val, igraph_vcount(graph), nv, nattr); 376| 1.62k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges: 344| 2.11k|) { 345| 2.11k| igraph_int_t origlen = newlen - nv; 346| 2.11k| igraph_error_t err = igraph_i_cattribute_add_vertices_or_edges_inner( 347| 2.11k| val, newlen, nv, nattr 348| 2.11k| ); 349| | 350| 2.11k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (350:9): [True: 133, False: 1.98k] ------------------ 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| 133| igraph_i_cattribute_revert_attribute_vector_sizes(val, origlen); 365| 133| } 366| | 367| 2.11k| return err; 368| 2.11k|} cattributes.c:igraph_i_cattribute_add_vertices_or_edges_inner: 269| 2.11k|) { 270| 2.11k| igraph_int_t length; 271| 2.11k| igraph_int_t nattrno = nattr == NULL ? 0 : igraph_attribute_record_list_size(nattr); ------------------ | Branch (271:28): [True: 1.80k, False: 314] ------------------ 272| 2.11k| igraph_int_t origlen = newlen - nv; 273| | 274| 2.11k| IGRAPH_ASSERT(origlen >= 0); ------------------ | | 924| 2.11k| do { \ | | 925| 2.11k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 2.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.11k] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 2.11k| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 2.11k] | | ------------------ ------------------ 275| | 276| | /* Find all the attributes that are newly added, and create new value vectors 277| | * for them in the original graph */ 278| 2.42k| for (igraph_int_t i = 0; i < nattrno; i++) { ------------------ | Branch (278:30): [True: 314, False: 2.11k] ------------------ 279| 314| const igraph_attribute_record_t *nattr_entry = igraph_attribute_record_list_get_ptr(nattr, i); 280| 314| const char *nname = nattr_entry->name; 281| 314| IGRAPH_CHECK(igraph_i_cattribute_find_or_create(val, nname, nattr_entry->type, origlen, NULL)); ------------------ | | 656| 314| do { \ | | 657| 314| igraph_error_t igraph_i_ret = (expr); \ | | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 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| 314| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 314] | | ------------------ ------------------ 282| 314| } 283| | 284| | /* Now append the new values */ 285| 2.11k| length = igraph_attribute_record_list_size(val); 286| 2.29k| for (igraph_int_t i = 0; i < length; i++) { ------------------ | Branch (286:30): [True: 314, False: 1.98k] ------------------ 287| 314| igraph_attribute_record_t *oldrec = igraph_attribute_record_list_get_ptr(val, i); 288| 314| const igraph_attribute_record_t *newrec = nattr ------------------ | Branch (288:51): [True: 314, False: 0] ------------------ 289| 314| ? igraph_i_cattribute_find_const(nattr, oldrec->name, oldrec->type) 290| 314| : NULL; 291| | 292| 314| IGRAPH_ASSERT(igraph_attribute_record_size(oldrec) == origlen); ------------------ | | 924| 314| do { \ | | 925| 314| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 314| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 314] | | ------------------ ------------------ 293| | 294| 314| if (newrec) { ------------------ | Branch (294:13): [True: 314, False: 0] ------------------ 295| | /* This attribute is present in nattr */ 296| 314| switch (oldrec->type) { 297| 145| case IGRAPH_ATTRIBUTE_NUMERIC: ------------------ | Branch (297:13): [True: 145, False: 169] ------------------ 298| 145| if (nv != igraph_vector_size(newrec->value.as_vector)) { ------------------ | Branch (298:21): [True: 0, False: 145] ------------------ 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| 145| IGRAPH_CHECK(igraph_vector_append( ------------------ | | 656| 145| do { \ | | 657| 145| igraph_error_t igraph_i_ret = (expr); \ | | 658| 145| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 145| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 145] | | | | ------------------ | | ------------------ | | 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| 145| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 145] | | ------------------ ------------------ 302| 145| oldrec->value.as_vector, newrec->value.as_vector 303| 145| )); 304| 145| break; 305| 169| case IGRAPH_ATTRIBUTE_STRING: ------------------ | Branch (305:13): [True: 169, False: 145] ------------------ 306| 169| if (nv != igraph_strvector_size(newrec->value.as_strvector)) { ------------------ | Branch (306:21): [True: 133, False: 36] ------------------ 307| 133| IGRAPH_ERROR("Invalid string attribute length.", IGRAPH_EINVAL); ------------------ | | 426| 133| do { \ | | 427| 133| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 133| return igraph_errno ; \ | | 429| 133| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 308| 133| } 309| 36| IGRAPH_CHECK(igraph_strvector_append( ------------------ | | 656| 36| do { \ | | 657| 36| igraph_error_t igraph_i_ret = (expr); \ | | 658| 36| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 36| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 36] | | | | ------------------ | | ------------------ | | 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| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 36] | | ------------------ ------------------ 310| 36| oldrec->value.as_strvector, newrec->value.as_strvector 311| 36| )); 312| 36| break; 313| 36| case IGRAPH_ATTRIBUTE_BOOLEAN: ------------------ | Branch (313:13): [True: 0, False: 314] ------------------ 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: 314] ------------------ 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| 314| } 328| 314| } 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.98k| return IGRAPH_SUCCESS; 338| 2.11k|} cattributes.c:igraph_i_cattribute_find_const: 90| 314|) { 91| 314| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name); 92| 314| const igraph_attribute_record_t *rec; 93| | 94| 314| if (index >= 0) { ------------------ | Branch (94:9): [True: 314, False: 0] ------------------ 95| 314| rec = igraph_attribute_record_list_get_ptr(attrs, index); 96| 314| if (type == IGRAPH_ATTRIBUTE_UNSPECIFIED || type == rec->type) { ------------------ | Branch (96:13): [True: 0, False: 314] | Branch (96:53): [True: 314, False: 0] ------------------ 97| 314| return rec; 98| 314| } 99| 314| } 100| | 101| 0| return NULL; 102| 314|} cattributes.c:igraph_i_cattribute_revert_attribute_vector_sizes: 179| 133| igraph_attribute_record_list_t *attrlist, igraph_int_t origlen) { 180| | 181| 133| igraph_int_t no_of_attrs = igraph_attribute_record_list_size(attrlist); 182| 266| for (igraph_int_t i = 0; i < no_of_attrs; i++) { ------------------ | Branch (182:30): [True: 133, False: 133] ------------------ 183| 133| igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrlist, i); 184| 133| IGRAPH_ASSERT(igraph_attribute_record_size(rec) >= origlen); ------------------ | | 924| 133| do { \ | | 925| 133| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 612| 133| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 133] | | | | ------------------ | | ------------------ | | 926| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 927| 0| } \ | | 928| 133| } while (0) | | ------------------ | | | Branch (928:14): [Folded, False: 133] | | ------------------ ------------------ 185| 133| if (igraph_attribute_record_resize(rec, origlen) != IGRAPH_SUCCESS) { ------------------ | Branch (185:13): [True: 0, False: 133] ------------------ 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| 133| } 191| 133|} cattributes.c:igraph_i_cattribute_add_edges: 1463| 488|) { 1464| 488| igraph_int_t ne = igraph_vector_int_size(edges) / 2; 1465| 488| igraph_i_cattributes_t *attr = graph->attr; 1466| 488| return igraph_i_cattribute_add_vertices_or_edges(&attr->eal, igraph_ecount(graph), ne, nattr); 1467| 488|} cattributes.c:igraph_i_cattribute_find: 69| 314|) { 70| 314| igraph_int_t index = igraph_i_cattribute_find_index(attrs, name); 71| 314| igraph_attribute_record_t *rec; 72| | 73| 314| if (index >= 0) { ------------------ | Branch (73:9): [True: 0, False: 314] ------------------ 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| 314| return NULL; 81| 314|} cattributes.c:igraph_i_cattribute_find_or_create: 147| 314|) { 148| 314| igraph_attribute_record_t *rec; 149| | 150| 314| rec = igraph_i_cattribute_find(attrs, name, IGRAPH_ATTRIBUTE_UNSPECIFIED); 151| 314| if (rec) { ------------------ | Branch (151:9): [True: 0, False: 314] ------------------ 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| 314| } else { 156| 314| IGRAPH_CHECK(igraph_attribute_record_list_push_back_new(attrs, &rec)); ------------------ | | 656| 314| do { \ | | 657| 314| igraph_error_t igraph_i_ret = (expr); \ | | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 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| 314| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 314] | | ------------------ ------------------ 157| 314| IGRAPH_CHECK(igraph_attribute_record_set_name(rec, name)); ------------------ | | 656| 314| do { \ | | 657| 314| igraph_error_t igraph_i_ret = (expr); \ | | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 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| 314| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 314] | | ------------------ ------------------ 158| 314| IGRAPH_CHECK(igraph_attribute_record_set_type(rec, type)); ------------------ | | 656| 314| do { \ | | 657| 314| igraph_error_t igraph_i_ret = (expr); \ | | 658| 314| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 314| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 314] | | | | ------------------ | | ------------------ | | 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| 314| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 314] | | ------------------ ------------------ 159| 314| } 160| | 161| 314| if (length > 0 && igraph_attribute_record_size(rec) < length) { ------------------ | Branch (161:9): [True: 0, False: 314] | 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| 314| if (ptr) { ------------------ | Branch (165:9): [True: 0, False: 314] ------------------ 166| 0| *ptr = rec; 167| 0| } 168| | 169| 314| return IGRAPH_SUCCESS; 170| 314|} cattributes.c:igraph_i_cattribute_find_index: 49| 628|) { 50| 628| igraph_int_t n = igraph_attribute_record_list_size(attrs); 51| 628| for (igraph_int_t i = 0; i < n; i++) { ------------------ | Branch (51:30): [True: 314, False: 314] ------------------ 52| 314| const igraph_attribute_record_t *rec = igraph_attribute_record_list_get_ptr(attrs, i); 53| 314| if (!strcmp(rec->name, name)) { ------------------ | Branch (53:13): [True: 314, False: 0] ------------------ 54| 314| return i; 55| 314| } 56| 314| } 57| 314| return -1; 58| 628|} igraph_empty: 64| 813|igraph_error_t igraph_empty(igraph_t *graph, igraph_int_t n, igraph_bool_t directed) { 65| 813| return igraph_empty_attrs(graph, n, directed, 0); 66| 813|} igraph_empty_attrs: 102| 813|) { 103| | 104| 813| if (n < 0) { ------------------ | Branch (104:9): [True: 0, False: 813] ------------------ 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| 813| memset(graph, 0, sizeof(igraph_t)); 109| | 110| 813| graph->n = 0; 111| 813| graph->directed = directed; 112| 813| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0); ------------------ | | 119| 813| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 813| do { \ | | | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 813] | | | | | | ------------------ | | | | ------------------ | | | | 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| 813| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | 120| 813| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 813| do { \ | | | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 813| * incorrect destructor function with the pointer */ \ | | | | 607| 813| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 813] | | | | ------------------ | | | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 813| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 813] | | ------------------ ------------------ 113| 813| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0); ------------------ | | 119| 813| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 813| do { \ | | | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 813] | | | | | | ------------------ | | | | ------------------ | | | | 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| 813| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | 120| 813| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 813| do { \ | | | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 813| * incorrect destructor function with the pointer */ \ | | | | 607| 813| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 813] | | | | ------------------ | | | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 813| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 813] | | ------------------ ------------------ 114| 813| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0); ------------------ | | 119| 813| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 813| do { \ | | | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 813] | | | | | | ------------------ | | | | ------------------ | | | | 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| 813| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | 120| 813| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 813| do { \ | | | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 813| * incorrect destructor function with the pointer */ \ | | | | 607| 813| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 813] | | | | ------------------ | | | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 813| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 813] | | ------------------ ------------------ 115| 813| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0); ------------------ | | 119| 813| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 813| do { \ | | | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 813] | | | | | | ------------------ | | | | ------------------ | | | | 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| 813| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | 120| 813| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 813| do { \ | | | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 813| * incorrect destructor function with the pointer */ \ | | | | 607| 813| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 813] | | | | ------------------ | | | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 813| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 813] | | ------------------ ------------------ 116| 813| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1); ------------------ | | 119| 813| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 813| do { \ | | | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 813] | | | | | | ------------------ | | | | ------------------ | | | | 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| 813| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | 120| 813| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 813| do { \ | | | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 813| * incorrect destructor function with the pointer */ \ | | | | 607| 813| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 813] | | | | ------------------ | | | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 813| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 813] | | ------------------ ------------------ 117| 813| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1); ------------------ | | 119| 813| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 813| do { \ | | | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 813] | | | | | | ------------------ | | | | ------------------ | | | | 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| 813| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | 120| 813| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 813| do { \ | | | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 813| * incorrect destructor function with the pointer */ \ | | | | 607| 813| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 813] | | | | ------------------ | | | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 813| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 813] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 813] | | ------------------ ------------------ 118| | 119| | /* init cache */ 120| 813| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 33| 813|#define IGRAPH_CALLOC(n,t) IGRAPH_I_ALLOC_CHECK_OVERFLOW(n, t, calloc(sizeof(t) * ((n) > 0 ? (n) : 1), 1)) | | ------------------ | | | | 31| 1.62k| (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: 813, Folded] | | | | ------------------ | | ------------------ ------------------ 121| 813| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph."); ------------------ | | 709| 813| do { \ | | 710| 813| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (713:14): [Folded, False: 813] | | ------------------ ------------------ 122| 813| IGRAPH_FINALLY(igraph_free, graph->cache); ------------------ | | 603| 813| do { \ | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 813| * incorrect destructor function with the pointer */ \ | | 607| 813| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 813] | | ------------------ | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 813| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 813] | | ------------------ ------------------ 123| 813| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 124| 813| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache); ------------------ | | 603| 813| do { \ | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 813| * incorrect destructor function with the pointer */ \ | | 607| 813| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 813] | | ------------------ | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 813| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 813] | | ------------------ ------------------ 125| | 126| 813| VECTOR(graph->os)[0] = 0; ------------------ | | 60| 813|#define VECTOR(v) ((v).stor_begin) ------------------ 127| 813| VECTOR(graph->is)[0] = 0; ------------------ | | 60| 813|#define VECTOR(v) ((v).stor_begin) ------------------ 128| | 129| | /* init attributes */ 130| 813| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 131| | 132| | /* add the vertices */ 133| 813| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 134| | 135| 813| IGRAPH_FINALLY_CLEAN(8); 136| 813| return IGRAPH_SUCCESS; 137| 813|} igraph_destroy: 155| 813|void igraph_destroy(igraph_t *graph) { 156| 813| igraph_i_attribute_destroy(graph); 157| | 158| 813| igraph_i_property_cache_destroy(graph->cache); 159| 813| IGRAPH_FREE(graph->cache); ------------------ | | 36| 813|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 160| | 161| 813| igraph_vector_int_destroy(&graph->from); 162| 813| igraph_vector_int_destroy(&graph->to); 163| 813| igraph_vector_int_destroy(&graph->oi); 164| 813| igraph_vector_int_destroy(&graph->ii); 165| 813| igraph_vector_int_destroy(&graph->os); 166| 813| igraph_vector_int_destroy(&graph->is); 167| 813|} igraph_add_edges: 257| 680|) { 258| 680| igraph_int_t no_of_edges = igraph_vector_int_size(&graph->from); 259| 680| igraph_int_t edges_to_add = igraph_vector_int_size(edges) / 2; 260| 680| igraph_int_t new_no_of_edges; 261| 680| igraph_int_t i = 0; 262| 680| igraph_vector_int_t newoi, newii; 263| 680| igraph_bool_t directed = igraph_is_directed(graph); 264| | 265| 680| if (igraph_vector_int_size(edges) % 2 != 0) { ------------------ | Branch (265:9): [True: 0, False: 680] ------------------ 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| 680| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) { ------------------ | Branch (268:9): [True: 192, False: 488] ------------------ 269| 192| IGRAPH_ERROR("Out-of-range vertex IDs when adding edges.", IGRAPH_EINVVID); ------------------ | | 426| 192| do { \ | | 427| 192| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 192| return igraph_errno ; \ | | 429| 192| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 270| 192| } 271| | 272| | /* from & to */ 273| 488| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges); ------------------ | | 47| 488| do { \ | | 48| 488| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 488| igraph_int_t _safe_sum; \ | | 50| 488| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 488] | | ------------------ | | 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| 488| *(res) = _safe_sum; \ | | 54| 488| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 488] | | ------------------ ------------------ 274| 488| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) { ------------------ | | 118| 488|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2) | | ------------------ | | | | 72| 488|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (274:9): [True: 0, False: 488] ------------------ 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| 488| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add)); ------------------ | | 656| 488| do { \ | | 657| 488| igraph_error_t igraph_i_ret = (expr); \ | | 658| 488| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 488| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 488] | | | | ------------------ | | ------------------ | | 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| 488| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 488] | | ------------------ ------------------ 279| 488| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add)); ------------------ | | 656| 488| do { \ | | 657| 488| igraph_error_t igraph_i_ret = (expr); \ | | 658| 488| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 488| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 488] | | | | ------------------ | | ------------------ | | 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| 488| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 488] | | ------------------ ------------------ 280| | 281| 3.16M| while (i < edges_to_add * 2) { ------------------ | Branch (281:12): [True: 3.16M, False: 488] ------------------ 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| 488|#define CHECK_ERR(expr) \ 299| 488| do { \ 300| 488| igraph_error_t err = (expr); \ 301| 488| if (err != IGRAPH_SUCCESS) { \ 302| 488| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ 303| 488| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ 304| 488| IGRAPH_FINALLY_EXIT(); \ 305| 488| IGRAPH_ERROR("Cannot add edges.", err); \ 306| 488| } \ 307| 488| } while (0) 308| | 309| | /* oi & ii */ 310| 488| IGRAPH_FINALLY_ENTER(); 311| 488| { 312| 488| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges)); ------------------ | | 299| 488| do { \ | | 300| 488| igraph_error_t err = (expr); \ | | 301| 488| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 488] | | ------------------ | | 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| 488| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 488] | | ------------------ ------------------ 313| 488| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi); ------------------ | | 603| 488| do { \ | | 604| 488| /* the following branch makes the compiler check the compatibility of \ | | 605| 488| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 488| * incorrect destructor function with the pointer */ \ | | 607| 488| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 488] | | ------------------ | | 608| 488| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 488| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 488] | | ------------------ ------------------ 314| 488| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges)); ------------------ | | 299| 488| do { \ | | 300| 488| igraph_error_t err = (expr); \ | | 301| 488| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 488] | | ------------------ | | 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| 488| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 488] | | ------------------ ------------------ 315| 488| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii); ------------------ | | 603| 488| do { \ | | 604| 488| /* the following branch makes the compiler check the compatibility of \ | | 605| 488| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 488| * incorrect destructor function with the pointer */ \ | | 607| 488| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 488] | | ------------------ | | 608| 488| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 488| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 488] | | ------------------ ------------------ 316| 488| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n)); ------------------ | | 299| 488| do { \ | | 300| 488| igraph_error_t err = (expr); \ | | 301| 488| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 488] | | ------------------ | | 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| 488| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 488] | | ------------------ ------------------ 317| 488| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n)); ------------------ | | 299| 488| do { \ | | 300| 488| igraph_error_t err = (expr); \ | | 301| 488| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 488] | | ------------------ | | 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| 488| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 488] | | ------------------ ------------------ 318| | 319| | /* Attributes */ 320| 488| if (graph->attr) { ------------------ | Branch (320:13): [True: 488, False: 0] ------------------ 321| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */ 322| 488| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr)); ------------------ | | 299| 488| do { \ | | 300| 488| igraph_error_t err = (expr); \ | | 301| 488| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (301:13): [True: 0, False: 488] | | ------------------ | | 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| 488| } while (0) | | ------------------ | | | Branch (307:14): [Folded, False: 488] | | ------------------ ------------------ 323| 488| } 324| | 325| | /* os & is, its length does not change, error safe */ 326| 488| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n); 327| 488| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n); 328| | 329| | /* everything went fine */ 330| 488| igraph_vector_int_destroy(&graph->oi); 331| 488| igraph_vector_int_destroy(&graph->ii); 332| 488| IGRAPH_FINALLY_CLEAN(2); 333| | 334| 488| graph->oi = newoi; 335| 488| graph->ii = newii; 336| 488| } 337| 0| IGRAPH_FINALLY_EXIT(); 338| | 339| 488|#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| 488| igraph_i_property_cache_invalidate_conditionally( 354| 488| graph, 355| 488| /* keep_always = */ 0, 356| | /* keep_when_false = */ 357| 488| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST), 358| | /* keep_when_true = */ 359| 488| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) | 360| 488| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 361| 488| (1 << IGRAPH_PROP_HAS_LOOP) | 362| 488| (1 << IGRAPH_PROP_HAS_MULTI) | 363| 488| (1 << IGRAPH_PROP_HAS_MUTUAL) 364| 488| ); 365| | 366| 488| return IGRAPH_SUCCESS; 367| 488|} igraph_add_vertices: 391| 1.62k|) { 392| 1.62k| igraph_int_t ec = igraph_ecount(graph); 393| 1.62k| igraph_int_t vc = igraph_vcount(graph); 394| 1.62k| igraph_int_t new_vc; 395| 1.62k| igraph_int_t i; 396| | 397| 1.62k| if (nv < 0) { ------------------ | Branch (397:9): [True: 0, False: 1.62k] ------------------ 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.62k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc); ------------------ | | 47| 1.62k| do { \ | | 48| 1.62k| igraph_int_t _safe_a = (a), _safe_b = (b); \ | | 49| 1.62k| igraph_int_t _safe_sum; \ | | 50| 1.62k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 1.62k] | | ------------------ | | 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.62k| *(res) = _safe_sum; \ | | 54| 1.62k| } while (0) | | ------------------ | | | Branch (54:14): [Folded, False: 1.62k] | | ------------------ ------------------ 402| 1.62k| if (new_vc > IGRAPH_VCOUNT_MAX) { ------------------ | | 100| 1.62k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1) | | ------------------ | | | | 72| 1.62k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (402:9): [True: 0, False: 1.62k] ------------------ 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.62k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1)); ------------------ | | 656| 1.62k| do { \ | | 657| 1.62k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.62k] | | | | ------------------ | | ------------------ | | 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.62k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.62k] | | ------------------ ------------------ 407| 1.62k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1)); ------------------ | | 656| 1.62k| do { \ | | 657| 1.62k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 1.62k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 1.62k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 1.62k] | | | | ------------------ | | ------------------ | | 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.62k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 1.62k] | | ------------------ ------------------ 408| | 409| 1.62k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */ 410| 1.62k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */ 411| 103M| for (i = graph->n + 1; i < new_vc + 1; i++) { ------------------ | Branch (411:28): [True: 103M, False: 1.62k] ------------------ 412| 103M| VECTOR(graph->os)[i] = ec; ------------------ | | 60| 103M|#define VECTOR(v) ((v).stor_begin) ------------------ 413| 103M| VECTOR(graph->is)[i] = ec; ------------------ | | 60| 103M|#define VECTOR(v) ((v).stor_begin) ------------------ 414| 103M| } 415| | 416| 1.62k| 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.62k| if (graph->attr) { ------------------ | Branch (422:9): [True: 1.62k, False: 0] ------------------ 423| 1.62k| igraph_error_t err; 424| 1.62k| IGRAPH_FINALLY_ENTER(); 425| 1.62k| err = igraph_i_attribute_add_vertices(graph, nv, attr); 426| 1.62k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (426:13): [True: 133, False: 1.49k] ------------------ 427| | /* Restore original vertex count on failure */ 428| 133| graph->n = vc; 429| 133| igraph_vector_int_resize(&graph->os, vc + 1); /* shrinks */ 430| 133| igraph_vector_int_resize(&graph->is, vc + 1); /* shrinks */ 431| 133| } 432| 1.62k| IGRAPH_FINALLY_EXIT(); 433| 1.62k| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (433:13): [True: 133, False: 1.49k] ------------------ 434| 133| IGRAPH_ERROR("Cannot add vertices.", err); ------------------ | | 426| 133| do { \ | | 427| 133| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 133| return igraph_errno ; \ | | 429| 133| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 435| 133| } 436| 1.62k| } 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.49k| igraph_i_property_cache_invalidate_conditionally( 458| 1.49k| graph, 459| | /* keep_always = */ 460| 1.49k| (1 << IGRAPH_PROP_HAS_LOOP) | 461| 1.49k| (1 << IGRAPH_PROP_HAS_MULTI) | 462| 1.49k| (1 << IGRAPH_PROP_HAS_MUTUAL) | 463| 1.49k| (1 << IGRAPH_PROP_IS_DAG) | 464| 1.49k| (1 << IGRAPH_PROP_IS_FOREST), 465| | /* keep_when_false = */ 466| 1.49k| igraph_vcount(graph) >= 2 ? ( ------------------ | Branch (466:9): [True: 619, False: 874] ------------------ 467| 619| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 468| 619| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) 469| 874| ) : 0, 470| | /* keep_when_true = */ 471| 1.49k| 0 472| 1.49k| ); 473| | 474| 1.49k| return IGRAPH_SUCCESS; 475| 1.62k|} igraph_vcount: 829| 5.42k|igraph_int_t igraph_vcount(const igraph_t *graph) { 830| 5.42k| return graph->n; 831| 5.42k|} igraph_ecount: 843| 2.11k|igraph_int_t igraph_ecount(const igraph_t *graph) { 844| 2.11k| return igraph_vector_int_size(&graph->from); 845| 2.11k|} igraph_is_directed: 1133| 680|igraph_bool_t igraph_is_directed(const igraph_t *graph) { 1134| 680| return graph->directed; 1135| 680|} type_indexededgelist.c:igraph_i_create_start_vectors: 1076| 976| igraph_vector_int_t *iindex, igraph_int_t nodes) { 1077| | 1078| 976|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) 1079| | 1080| 976| igraph_int_t no_of_nodes; 1081| 976| igraph_int_t no_of_edges; 1082| 976| igraph_int_t i, j, idx; 1083| | 1084| 976| no_of_nodes = nodes; 1085| 976| no_of_edges = igraph_vector_int_size(el); 1086| | 1087| | /* result */ 1088| | 1089| 976| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1)); ------------------ | | 656| 976| do { \ | | 657| 976| igraph_error_t igraph_i_ret = (expr); \ | | 658| 976| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 976| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 976] | | | | ------------------ | | ------------------ | | 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| 976| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 976] | | ------------------ ------------------ 1090| | 1091| | /* create the index */ 1092| | 1093| 976| if (no_of_edges == 0) { ------------------ | Branch (1093:9): [True: 294, False: 682] ------------------ 1094| | /* empty graph */ 1095| 294| igraph_vector_int_null(res); 1096| 682| } else { 1097| 682| 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: 682] ------------------ 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: 682] ------------------ 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.13M, False: 6.32M] ------------------ 1104| 4.13M| idx++; VECTOR(*res)[idx] = i; ------------------ | | 60| 4.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 1105| 4.13M| } 1106| 6.32M| } 1107| 682| j = EDGE(VECTOR(*res)[idx]); ------------------ | | 1078| 682|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 682|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 60| 682|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1108| 20.0M| for (i = 0; i < no_of_nodes - j; i++) { ------------------ | Branch (1108:21): [True: 20.0M, False: 682] ------------------ 1109| 20.0M| idx++; VECTOR(*res)[idx] = no_of_edges; ------------------ | | 60| 20.0M|#define VECTOR(v) ((v).stor_begin) ------------------ 1110| 20.0M| } 1111| 682| } 1112| | 1113| | /* clean */ 1114| | 1115| 976|# undef EDGE 1116| 976| return IGRAPH_SUCCESS; 1117| 976|} igraph_dl_yylex_destroy_wrapper: 37| 1.82k|void igraph_dl_yylex_destroy_wrapper (void *scanner ) { 38| 1.82k| (void) igraph_dl_yylex_destroy(scanner); 39| 1.82k|} igraph_read_graph_dl: 68| 2.31k| igraph_bool_t directed) { 69| | 70| 2.31k| igraph_int_t n, n2; 71| 2.31k| const igraph_strvector_t *namevec = 0; 72| 2.31k| igraph_attribute_record_list_t name, weight; 73| 2.31k| igraph_attribute_record_list_t *pname = NULL; 74| 2.31k| igraph_attribute_record_list_t *pweight = NULL; 75| 2.31k| igraph_attribute_record_t *namerec, *weightrec; 76| 2.31k| const char *namestr = "name", *weightstr = "weight"; 77| 2.31k| igraph_i_dl_parsedata_t context; 78| | 79| 2.31k| context.eof = 0; 80| 2.31k| context.mode = 0; 81| 2.31k| context.n = -1; 82| 2.31k| context.from = 0; 83| 2.31k| context.to = 0; 84| 2.31k| context.errmsg[0] = '\0'; 85| 2.31k| context.igraph_errno = IGRAPH_SUCCESS; 86| | 87| 2.31k| IGRAPH_VECTOR_INT_INIT_FINALLY(&context.edges, 0); ------------------ | | 119| 2.31k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 656| 2.31k| do { \ | | | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 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.31k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | 120| 2.31k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 603| 2.31k| do { \ | | | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.31k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.31k] | | | | ------------------ | | | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | | Branch (120:64): [Folded, False: 2.31k] | | ------------------ ------------------ 88| 2.31k| IGRAPH_VECTOR_INIT_FINALLY(&context.weights, 0); ------------------ | | 104| 2.31k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 656| 2.31k| do { \ | | | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 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.31k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | 105| 2.31k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 603| 2.31k| do { \ | | | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.31k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.31k] | | | | ------------------ | | | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | | Branch (105:60): [Folded, False: 2.31k] | | ------------------ ------------------ 89| 2.31k| IGRAPH_CHECK(igraph_strvector_init(&context.labels, 0)); ------------------ | | 656| 2.31k| do { \ | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | ------------------ | | ------------------ | | 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.31k| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 2.31k] | | ------------------ ------------------ 90| 2.31k| IGRAPH_FINALLY(igraph_strvector_destroy, &context.labels); ------------------ | | 603| 2.31k| do { \ | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | 607| 2.31k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.31k] | | ------------------ | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.31k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.31k] | | ------------------ ------------------ 91| 2.31k| IGRAPH_TRIE_INIT_FINALLY(&context.trie, /*names=*/ 1); ------------------ | | 55| 2.31k| do { IGRAPH_CHECK(igraph_trie_init(tr, sk)); \ | | ------------------ | | | | 656| 2.31k| do { \ | | | | 657| 2.31k| igraph_error_t igraph_i_ret = (expr); \ | | | | 658| 2.31k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 612| 2.31k| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | | | ------------------ | | | | | | | Branch (612:32): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 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.31k| } while (0) | | | | ------------------ | | | | | Branch (661:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | 56| 2.31k| IGRAPH_FINALLY(igraph_trie_destroy, tr); } while (0) | | ------------------ | | | | 603| 2.31k| do { \ | | | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | | | 607| 2.31k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (607:13): [Folded, False: 2.31k] | | | | ------------------ | | | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 609| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (609:14): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ | | | Branch (56:59): [Folded, False: 2.31k] | | ------------------ ------------------ 92| | 93| 2.31k| igraph_dl_yylex_init_extra(&context, &context.scanner); 94| 2.31k| IGRAPH_FINALLY(igraph_dl_yylex_destroy_wrapper, context.scanner); ------------------ | | 603| 2.31k| do { \ | | 604| 2.31k| /* the following branch makes the compiler check the compatibility of \ | | 605| 2.31k| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 2.31k| * incorrect destructor function with the pointer */ \ | | 607| 2.31k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 2.31k] | | ------------------ | | 608| 2.31k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 2.31k| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 2.31k] | | ------------------ ------------------ 95| | 96| 2.31k| igraph_dl_yyset_in(instream, context.scanner); 97| | 98| | /* Use ENTER/EXIT to avoid destroying context.scanner before this function returns */ 99| 2.31k| IGRAPH_FINALLY_ENTER(); 100| 2.31k| int err = igraph_dl_yyparse(&context); 101| 2.31k| IGRAPH_FINALLY_EXIT(); 102| 2.31k| switch (err) { 103| 813| case 0: /* success */ ------------------ | Branch (103:5): [True: 813, False: 1.49k] ------------------ 104| 813| break; 105| 1.49k| case 1: /* parse error */ ------------------ | Branch (105:5): [True: 1.49k, False: 813] ------------------ 106| 1.49k| if (context.errmsg[0] != 0) { ------------------ | Branch (106:13): [True: 1.44k, False: 51] ------------------ 107| 1.44k| IGRAPH_ERROR(context.errmsg, IGRAPH_PARSEERROR); ------------------ | | 426| 1.44k| do { \ | | 427| 1.44k| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 428| 1.44k| return igraph_errno ; \ | | 429| 1.44k| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 108| 1.44k| } else if (context.igraph_errno != IGRAPH_SUCCESS) { ------------------ | Branch (108:20): [True: 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.31k] ------------------ 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.31k] ------------------ 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.31k| } 125| | 126| | /* Extend the weight vector, if needed */ 127| 813| n = igraph_vector_size(&context.weights); 128| 813| n2 = igraph_vector_int_size(&context.edges) / 2; 129| 813| if (n != 0) { ------------------ | Branch (129:9): [True: 255, False: 558] ------------------ 130| 255| IGRAPH_CHECK(igraph_vector_resize(&context.weights, n2)); ------------------ | | 656| 255| do { \ | | 657| 255| igraph_error_t igraph_i_ret = (expr); \ | | 658| 255| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 255| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 255] | | | | ------------------ | | ------------------ | | 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| 255| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 255] | | ------------------ ------------------ 131| 9.47k| for (; n < n2; n++) { ------------------ | Branch (131:16): [True: 9.21k, False: 255] ------------------ 132| 9.21k| VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 60| 9.21k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(context.weights)[n] = IGRAPH_NAN; ------------------ | | 138| 9.21k|#define IGRAPH_NAN ((double)NAN) ------------------ 133| 9.21k| } 134| 255| } 135| | 136| | /* Check number of vertices */ 137| 813| if (n2 > 0) { ------------------ | Branch (137:9): [True: 591, False: 222] ------------------ 138| 591| n = igraph_vector_int_max(&context.edges); 139| 591| } else { 140| 222| n = 0; 141| 222| } 142| 813| if (n >= context.n) { ------------------ | Branch (142:9): [True: 293, False: 520] ------------------ 143| 293| IGRAPH_WARNING("More vertices than specified in `DL' file"); ------------------ | | 797| 293| do { \ | | 798| 293| igraph_warning(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 799| 293| } while (0) | | ------------------ | | | Branch (799:14): [Folded, False: 293] | | ------------------ ------------------ 144| 293| context.n = n; 145| 293| } 146| | 147| | /* Prepare attributes */ 148| | 149| | /* Labels */ 150| 813| if (igraph_strvector_size(&context.labels) != 0) { ------------------ | Branch (150:9): [True: 94, False: 719] ------------------ 151| 94| namevec = (const igraph_strvector_t*) &context.labels; 152| 719| } else if (igraph_trie_size(&context.trie) != 0) { ------------------ | Branch (152:16): [True: 75, False: 644] ------------------ 153| 75| namevec = igraph_i_trie_borrow_keys(&context.trie); 154| 75| } 155| 813| if (namevec) { ------------------ | Branch (155:9): [True: 169, False: 644] ------------------ 156| 169| IGRAPH_CHECK(igraph_attribute_record_list_init(&name, 1)); ------------------ | | 656| 169| do { \ | | 657| 169| igraph_error_t igraph_i_ret = (expr); \ | | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 169] | | | | ------------------ | | ------------------ | | 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| 169| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 169] | | ------------------ ------------------ 157| 169| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &name); ------------------ | | 603| 169| do { \ | | 604| 169| /* the following branch makes the compiler check the compatibility of \ | | 605| 169| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 169| * incorrect destructor function with the pointer */ \ | | 607| 169| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 169] | | ------------------ | | 608| 169| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 169| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 169] | | ------------------ ------------------ 158| | 159| 169| namerec = igraph_attribute_record_list_get_ptr(&name, 0); 160| 169| IGRAPH_CHECK(igraph_attribute_record_set_name(namerec, namestr)); ------------------ | | 656| 169| do { \ | | 657| 169| igraph_error_t igraph_i_ret = (expr); \ | | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 169] | | | | ------------------ | | ------------------ | | 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| 169| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 169] | | ------------------ ------------------ 161| 169| IGRAPH_CHECK(igraph_attribute_record_set_type(namerec, IGRAPH_ATTRIBUTE_STRING)); ------------------ | | 656| 169| do { \ | | 657| 169| igraph_error_t igraph_i_ret = (expr); \ | | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 169] | | | | ------------------ | | ------------------ | | 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| 169| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 169] | | ------------------ ------------------ 162| 169| IGRAPH_CHECK(igraph_strvector_update(namerec->value.as_strvector, namevec)); ------------------ | | 656| 169| do { \ | | 657| 169| igraph_error_t igraph_i_ret = (expr); \ | | 658| 169| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 169| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 169] | | | | ------------------ | | ------------------ | | 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| 169| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 169] | | ------------------ ------------------ 163| | 164| 169| pname = &name; 165| 169| } 166| | 167| | /* Weights */ 168| 813| if (igraph_vector_size(&context.weights) != 0) { ------------------ | Branch (168:9): [True: 255, False: 558] ------------------ 169| 255| IGRAPH_CHECK(igraph_attribute_record_list_init(&weight, 1)); ------------------ | | 656| 255| do { \ | | 657| 255| igraph_error_t igraph_i_ret = (expr); \ | | 658| 255| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 255| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 255] | | | | ------------------ | | ------------------ | | 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| 255| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 255] | | ------------------ ------------------ 170| 255| IGRAPH_FINALLY(igraph_attribute_record_list_destroy, &weight); ------------------ | | 603| 255| do { \ | | 604| 255| /* the following branch makes the compiler check the compatibility of \ | | 605| 255| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 255| * incorrect destructor function with the pointer */ \ | | 607| 255| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 255] | | ------------------ | | 608| 255| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 255| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 255] | | ------------------ ------------------ 171| | 172| 255| weightrec = igraph_attribute_record_list_get_ptr(&weight, 0); 173| 255| IGRAPH_CHECK(igraph_attribute_record_set_name(weightrec, weightstr)); ------------------ | | 656| 255| do { \ | | 657| 255| igraph_error_t igraph_i_ret = (expr); \ | | 658| 255| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 255| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 255] | | | | ------------------ | | ------------------ | | 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| 255| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 255] | | ------------------ ------------------ 174| 255| IGRAPH_CHECK(igraph_attribute_record_set_type(weightrec, IGRAPH_ATTRIBUTE_NUMERIC)); ------------------ | | 656| 255| do { \ | | 657| 255| igraph_error_t igraph_i_ret = (expr); \ | | 658| 255| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 255| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 255] | | | | ------------------ | | ------------------ | | 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| 255| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 255] | | ------------------ ------------------ 175| 255| igraph_vector_swap(weightrec->value.as_vector, &context.weights); 176| | 177| 255| pweight = &weight; 178| 255| } 179| | 180| | /* Create graph */ 181| 813| IGRAPH_CHECK(igraph_empty(graph, 0, directed)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 0, False: 813] | | | | ------------------ | | ------------------ | | 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| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 813] | | ------------------ ------------------ 182| 813| IGRAPH_FINALLY(igraph_destroy, graph); ------------------ | | 603| 813| do { \ | | 604| 813| /* the following branch makes the compiler check the compatibility of \ | | 605| 813| * func and ptr to detect cases when we are accidentally invoking an \ | | 606| 813| * incorrect destructor function with the pointer */ \ | | 607| 813| if (0) { func(ptr); } \ | | ------------------ | | | Branch (607:13): [Folded, False: 813] | | ------------------ | | 608| 813| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 609| 813| } while (0) | | ------------------ | | | Branch (609:14): [Folded, False: 813] | | ------------------ ------------------ 183| 813| IGRAPH_CHECK(igraph_add_vertices(graph, context.n, pname)); ------------------ | | 656| 813| do { \ | | 657| 813| igraph_error_t igraph_i_ret = (expr); \ | | 658| 813| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 813| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 133, False: 680] | | | | ------------------ | | ------------------ | | 659| 133| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 133| do { \ | | | | 427| 133| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 133| return igraph_errno ; \ | | | | 429| 133| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 133| } \ | | 661| 813| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 680] | | ------------------ ------------------ 184| 680| IGRAPH_CHECK(igraph_add_edges(graph, &context.edges, pweight)); ------------------ | | 656| 680| do { \ | | 657| 680| igraph_error_t igraph_i_ret = (expr); \ | | 658| 680| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 612| 680| #define IGRAPH_UNLIKELY(a) __builtin_expect(!!(a), 0) | | | | ------------------ | | | | | Branch (612:32): [True: 192, False: 488] | | | | ------------------ | | ------------------ | | 659| 192| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 426| 192| do { \ | | | | 427| 192| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 428| 192| return igraph_errno ; \ | | | | 429| 192| } while (0) | | | | ------------------ | | | | | Branch (429:14): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 660| 192| } \ | | 661| 680| } while (0) | | ------------------ | | | Branch (661:14): [Folded, False: 488] | | ------------------ ------------------ 185| | 186| 488| if (pweight) { ------------------ | Branch (186:9): [True: 145, False: 343] ------------------ 187| 145| igraph_attribute_record_list_destroy(pweight); 188| 145| IGRAPH_FINALLY_CLEAN(1); 189| 145| } 190| | 191| 488| if (pname) { ------------------ | Branch (191:9): [True: 35, False: 453] ------------------ 192| 35| igraph_attribute_record_list_destroy(pname); 193| 35| IGRAPH_FINALLY_CLEAN(1); 194| 35| } 195| | 196| | /* don't destroy the graph itself but pop it from the finally stack */ 197| 488| IGRAPH_FINALLY_CLEAN(1); 198| | 199| 488| igraph_trie_destroy(&context.trie); 200| 488| igraph_strvector_destroy(&context.labels); 201| 488| igraph_vector_int_destroy(&context.edges); 202| 488| igraph_vector_destroy(&context.weights); 203| 488| igraph_dl_yylex_destroy(context.scanner); 204| 488| IGRAPH_FINALLY_CLEAN(5); 205| | 206| 488| return IGRAPH_SUCCESS; 207| 680|} 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: 39, False: 6.21M] ------------------ 93| 39| IGRAPH_ERROR("Failed to parse integer.", val > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 426| 39| do { \ | | 427| 78| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (427:63): [True: 37, False: 2] | | ------------------ | | 428| 78| return igraph_errno ; \ | | ------------------ | | | Branch (428:16): [True: 37, False: 2] | | ------------------ | | 429| 39| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 94| 39| } 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: 24, False: 38.9k] ------------------ 146| 24| IGRAPH_ERROR("Failed to parse real number.", *value > 0 ? IGRAPH_EOVERFLOW : IGRAPH_EUNDERFLOW); ------------------ | | 426| 24| do { \ | | 427| 48| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | ------------------ | | | Branch (427:63): [True: 13, False: 11] | | ------------------ | | 428| 48| return igraph_errno ; \ | | ------------------ | | | Branch (428:16): [True: 13, False: 11] | | ------------------ | | 429| 24| } while (0) | | ------------------ | | | Branch (429:14): [Folded, False: 0] | | ------------------ ------------------ 147| 24| } 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|}